libraries['pbd3'],
libraries['gtkmm2'],
libraries['sigc2'],
- libraries['libgnomecanvasmm'],
+# libraries['libgnomecanvasmm'],
libraries['sysmidi'],
libraries['sndfile'],
libraries['lrdf'],
ardour_ui2.cc
ardour_ui_dialogs.cc
audio_time_axis.cc
-automation_line.c
+automation_line.cc
canvas-imageframe.cc
about.cc
editor.cc
#include <gtkmm/window.h>
#include <gtkmm/pixmap.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
class ARDOUR_UI;
#include <cmath>
-#include <gtk-canvas.h>
-
#include <pbd/xml++.h>
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/pix.h>
-#include <gtkmm2ext/spinner.h>
-#include <gtkmm2ext/pixmap_button.h>
-#include <gtkmm2ext/popup_selector.h>
#include <gtkmm2ext/click_box.h>
#include <gtkmm2ext/selector.h>
#include <ardour/ardour.h>
#endif
if (timestretch_rect == 0) {
- timestretch_rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(canvas_display),
- gtk_canvas_simplerect_get_type(),
+ timestretch_rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(canvas_display),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
NULL);
}
- gtk_canvas_item_show (timestretch_rect);
- gtk_canvas_item_raise_to_top (timestretch_rect);
+ gnome_canvas_item_show (timestretch_rect);
+ gnome_canvas_item_raise_to_top (timestretch_rect);
x1 = start / editor.get_current_zoom();
x2 = (end - 1) / editor.get_current_zoom();
TimeAxisView::hide_timestretch ();
if (timestretch_rect) {
- gtk_canvas_item_hide (timestretch_rect);
+ gnome_canvas_item_hide (timestretch_rect);
}
}
if (showit != gain_track->marked_for_display()) {
if (showit) {
gain_track->set_marked_for_display (true);
- gtk_canvas_item_show (gain_track->canvas_display);
+ gnome_canvas_item_show (gain_track->canvas_display);
gain_track->get_state_node()->add_property ("shown", X_("yes"));
} else {
gain_track->set_marked_for_display (false);
if (showit != pan_track->marked_for_display()) {
if (showit) {
pan_track->set_marked_for_display (true);
- gtk_canvas_item_show (pan_track->canvas_display);
+ gnome_canvas_item_show (pan_track->canvas_display);
pan_track->get_state_node()->add_property ("shown", X_("yes"));
} else {
pan_track->set_marked_for_display (false);
if (showit) {
ran->view->set_marked_for_display (true);
- gtk_canvas_item_show (ran->view->canvas_display);
+ gnome_canvas_item_show (ran->view->canvas_display);
} else {
rai->redirect->mark_automation_visible (ran->what, true);
ran->view->set_marked_for_display (false);
#define __ardour_trackview_h__
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <gtkmm2ext/selector.h>
#include <gtkmm2ext/popup_selector.h>
#include <list>
void add_redirect_automation_curve (ARDOUR::Redirect*, uint32_t);
void add_existing_redirect_automation_curves (ARDOUR::Redirect*);
- GtkCanvasItem *timestretch_rect;
+ GnomeCanvasItem *timestretch_rect;
void timestretch (jack_nframes_t start, jack_nframes_t end);
using namespace std;
using namespace ARDOUR;
-AutomationGainLine::AutomationGainLine (string name, Session& s, TimeAxisView& tv, GtkCanvasItem* parent,
+AutomationGainLine::AutomationGainLine (string name, Session& s, TimeAxisView& tv, GnomeCanvasItem* parent,
Curve& c,
- gint (*point_callback)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_callback)(GtkCanvasItem*, GdkEvent*, gpointer))
+ gint (*point_callback)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_callback)(GnomeCanvasItem*, GdkEvent*, gpointer))
: AutomationLine (name, tv, parent, c, point_callback, line_callback),
session (s)
{
#define __ardour_gtk_automation_gain_line_h__
#include <ardour/ardour.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <gtkmm.h>
#include "automation_line.h"
class AutomationGainLine : public AutomationLine
{
public:
- AutomationGainLine (string name, ARDOUR::Session&, TimeAxisView&, GtkCanvasItem* parent,
+ AutomationGainLine (string name, ARDOUR::Session&, TimeAxisView&, GnomeCanvasItem* parent,
ARDOUR::Curve&,
- gint (*point_callback)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_callback)(GtkCanvasItem*, GdkEvent*, gpointer));
+ gint (*point_callback)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_callback)(GnomeCanvasItem*, GdkEvent*, gpointer));
void view_to_model_y (double&);
void model_to_view_y (double&);
using namespace ARDOUR;
using namespace Editing;
-ControlPoint::ControlPoint (AutomationLine& al, gint (*event_handler)(GtkCanvasItem*, GdkEvent*, gpointer))
+ControlPoint::ControlPoint (AutomationLine& al, gint (*event_handler)(GnomeCanvasItem*, GdkEvent*, gpointer))
: line (al)
{
model = al.the_list().end();
_size = 4.0;
selected = false;
- item = gtk_canvas_item_new (line.canvas_group(),
- gtk_canvas_simplerect_get_type(),
+ item = gnome_canvas_item_new (line.canvas_group(),
+ gnome_canvas_simplerect_get_type(),
"draw", (gboolean) TRUE,
"fill", (gboolean) FALSE,
"fill_color_rgba", color_map[cControlPointFill],
_size = other._size;
selected = false;
- item = gtk_canvas_item_new (line.canvas_group(),
- gtk_canvas_simplerect_get_type(),
+ item = gnome_canvas_item_new (line.canvas_group(),
+ gnome_canvas_simplerect_get_type(),
"fill", (gboolean) FALSE,
"outline_color_rgba", color_map[cEnteredControlPointOutline],
"outline_pixels", (gint) 1,
void
ControlPoint::hide ()
{
- gtk_canvas_item_hide (item);
+ gnome_canvas_item_hide (item);
}
void
ControlPoint::show()
{
- gtk_canvas_item_show (item);
+ gnome_canvas_item_show (item);
}
void
ControlPoint::set_visible (bool yn)
{
- gtk_canvas_item_set (item, "draw", (gboolean) yn, NULL);
+ gnome_canvas_item_set (item, "draw", (gboolean) yn, NULL);
}
void
{
if (entered) {
if (selected) {
- gtk_canvas_item_set (item, "outline_color_rgba", color_map[cEnteredControlPointSelected], NULL);
+ gnome_canvas_item_set (item, "outline_color_rgba", color_map[cEnteredControlPointSelected], NULL);
set_visible(true);
} else {
- gtk_canvas_item_set (item, "outline_color_rgba", color_map[cEnteredControlPoint], NULL);
+ gnome_canvas_item_set (item, "outline_color_rgba", color_map[cEnteredControlPoint], NULL);
if (hide_too) {
set_visible(false);
}
} else {
if (selected) {
- gtk_canvas_item_set (item, "outline_color_rgba", color_map[cControlPointSelected], NULL);
+ gnome_canvas_item_set (item, "outline_color_rgba", color_map[cControlPointSelected], NULL);
set_visible(true);
} else {
- gtk_canvas_item_set (item, "outline_color_rgba", color_map[cControlPoint], NULL);
+ gnome_canvas_item_set (item, "outline_color_rgba", color_map[cControlPoint], NULL);
if (hide_too) {
set_visible(false);
}
#if 0
if (_size > 6.0) {
- gtk_canvas_item_set (item,
+ gnome_canvas_item_set (item,
"fill", (gboolean) TRUE,
NULL);
} else {
- gtk_canvas_item_set (item,
+ gnome_canvas_item_set (item,
"fill", (gboolean) FALSE,
NULL);
}
break;
}
- gtk_canvas_item_set (item,
+ gnome_canvas_item_set (item,
"x1", x1,
"x2", x2,
"y1", y - half_size,
/*****/
-AutomationLine::AutomationLine (string name, TimeAxisView& tv, GtkCanvasItem* parent, AutomationList& al,
- gint (*point_handler)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_handler)(GtkCanvasItem*, GdkEvent*, gpointer))
+AutomationLine::AutomationLine (string name, TimeAxisView& tv, GnomeCanvasItem* parent, AutomationList& al,
+ gint (*point_handler)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_handler)(GnomeCanvasItem*, GdkEvent*, gpointer))
: trackview (tv),
_name (name),
alist (al)
terminal_points_can_slide = true;
_height = 0;
- group = gtk_canvas_item_new (GTK_CANVAS_GROUP(parent),
- gtk_canvas_group_get_type(),
+ group = gnome_canvas_item_new (GNOME_CANVAS_GROUP(parent),
+ gnome_canvas_group_get_type(),
"x", 0.0,
"y", 0.0,
NULL);
- line = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_line_get_type(),
+ line = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_line_get_type(),
"width_pixels", (guint) 1,
NULL);
AutomationLine::~AutomationLine ()
{
if (point_coords) {
- gtk_canvas_points_unref (point_coords);
+ gnome_canvas_points_unref (point_coords);
}
vector_delete (&control_points);
void
AutomationLine::show ()
{
- gtk_canvas_item_show (line);
+ gnome_canvas_item_show (line);
if (points_visible) {
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
void
AutomationLine::hide ()
{
- gtk_canvas_item_hide (line);
+ gnome_canvas_item_hide (line);
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
(*i)->hide();
}
AutomationLine::set_line_color (uint32_t color)
{
_line_color = color;
- gtk_canvas_item_set (line, "fill_color_rgba", color, NULL);
+ gnome_canvas_item_set (line, "fill_color_rgba", color, NULL);
}
void
void
AutomationLine::update_line ()
{
- gtk_canvas_item_set (line, "points", point_coords, NULL);
+ gnome_canvas_item_set (line, "points", point_coords, NULL);
}
void
}
void
-AutomationLine::determine_visible_control_points (GtkCanvasPoints* points)
+AutomationLine::determine_visible_control_points (GnomeCanvasPoints* points)
{
uint32_t xi, yi, view_index, pi;
int n;
for (vector<ControlPoint*>::iterator i = control_points.begin(); i != control_points.end(); ++i) {
(*i)->hide();
}
- gtk_canvas_item_hide (line);
+ gnome_canvas_item_hide (line);
if (points == 0 || points->num_points == 0) {
return;
if (point_coords) {
if (point_coords->num_points < (int) npoints) {
- gtk_canvas_points_unref (point_coords);
+ gnome_canvas_points_unref (point_coords);
point_coords = get_canvas_points ("autoline", npoints);
} else {
point_coords->num_points = npoints;
}
// cerr << "set al2 points, nc = " << point_coords->num_points << endl;
- gtk_canvas_item_set (line, "points", point_coords, NULL);
+ gnome_canvas_item_set (line, "points", point_coords, NULL);
if (_visible) {
- gtk_canvas_item_show (line);
+ gnome_canvas_item_show (line);
}
}
}
bool
-AutomationLine::invalid_point (GtkCanvasPoints* p, uint32_t index)
+AutomationLine::invalid_point (GnomeCanvasPoints* p, uint32_t index)
{
return p->coords[index*2] == max_frames && p->coords[(index*2)+1] == DBL_MAX;
}
void
-AutomationLine::invalidate_point (GtkCanvasPoints* p, uint32_t index)
+AutomationLine::invalidate_point (GnomeCanvasPoints* p, uint32_t index)
{
p->coords[index*2] = max_frames;
p->coords[(index*2)+1] = DBL_MAX;
void
AutomationLine::reset_callback (const AutomationList& events)
{
- GtkCanvasPoints *tmp_points;
+ GnomeCanvasPoints *tmp_points;
uint32_t npoints = events.size();
if (npoints == 0) {
delete *i;
}
control_points.clear ();
- gtk_canvas_item_hide (line);
+ gnome_canvas_item_hide (line);
return;
}
tmp_points->num_points = npoints;
determine_visible_control_points (tmp_points);
- gtk_canvas_points_unref (tmp_points);
+ gnome_canvas_points_unref (tmp_points);
}
void
#include <sys/types.h>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <sigc++/signal.h>
#include <pbd/undo.h>
class ControlPoint
{
public:
- ControlPoint (AutomationLine& al, gint (*event_handler)(GtkCanvasItem*, GdkEvent*, gpointer));
+ ControlPoint (AutomationLine& al, gint (*event_handler)(GnomeCanvasItem*, GdkEvent*, gpointer));
ControlPoint (const ControlPoint&, bool dummy_arg_to_force_special_copy_constructor);
~ControlPoint ();
void set_size (double);
void set_visible (bool);
- GtkCanvasItem* item;
+ GnomeCanvasItem* item;
AutomationLine& line;
uint32_t view_index;
ARDOUR::AutomationList::iterator model;
class AutomationLine : public sigc::trackable
{
public:
- AutomationLine (string name, TimeAxisView&, GtkCanvasItem *, ARDOUR::AutomationList&,
- gint (*point_event_handler)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_event_handler)(GtkCanvasItem*, GdkEvent*, gpointer));
+ AutomationLine (string name, TimeAxisView&, GnomeCanvasItem *, ARDOUR::AutomationList&,
+ gint (*point_event_handler)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_event_handler)(GnomeCanvasItem*, GdkEvent*, gpointer));
virtual ~AutomationLine ();
TimeAxisView& trackview;
- GtkCanvasGroup* canvas_group() const { return GTK_CANVAS_GROUP(group); }
- GtkCanvasItem* parent_group() const { return _parent_group; }
- GtkCanvasItem* grab_item() const { return line; }
+ GnomeCanvasGroup* canvas_group() const { return GNOME_CANVAS_GROUP(group); }
+ GnomeCanvasItem* parent_group() const { return _parent_group; }
+ GnomeCanvasItem* grab_item() const { return line; }
void show_selection();
void hide_selection ();
void set_point_size (double size);
- static void invalidate_point (GtkCanvasPoints*, uint32_t index);
- static bool invalid_point (GtkCanvasPoints*, uint32_t index);
+ static void invalidate_point (GnomeCanvasPoints*, uint32_t index);
+ static bool invalid_point (GnomeCanvasPoints*, uint32_t index);
virtual string get_verbose_cursor_string (float);
virtual void view_to_model_y (double&) = 0;
bool no_draw : 1;
bool points_visible : 1;
- GtkCanvasItem* _parent_group;
- GtkCanvasItem* group;
- GtkCanvasItem* line; /* line */
- GtkCanvasPoints* point_coords; /* coordinates for canvas line */
+ GnomeCanvasItem* _parent_group;
+ GnomeCanvasItem* group;
+ GnomeCanvasItem* line; /* line */
+ GnomeCanvasPoints* point_coords; /* coordinates for canvas line */
vector<ControlPoint*> control_points; /* visible control points */
- gint (*point_callback)(GtkCanvasItem*, GdkEvent*, gpointer);
+ gint (*point_callback)(GnomeCanvasItem*, GdkEvent*, gpointer);
- void determine_visible_control_points (GtkCanvasPoints*);
+ void determine_visible_control_points (GnomeCanvasPoints*);
void sync_model_from (ControlPoint&);
void sync_model_with_view_point (ControlPoint&);
void sync_model_with_view_line (uint32_t, uint32_t);
using namespace ARDOUR;
-AutomationPanLine::AutomationPanLine (string name, Session& s, TimeAxisView& tv, GtkCanvasItem* parent,
+AutomationPanLine::AutomationPanLine (string name, Session& s, TimeAxisView& tv, GnomeCanvasItem* parent,
Curve& c,
- gint (*point_callback)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_callback)(GtkCanvasItem*, GdkEvent*, gpointer))
+ gint (*point_callback)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_callback)(GnomeCanvasItem*, GdkEvent*, gpointer))
: AutomationLine (name, tv, parent, c, point_callback, line_callback),
session (s)
{
#define __ardour_gtk_automation_pan_line_h__
#include <ardour/ardour.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <gtkmm.h>
#include "automation_line.h"
class AutomationPanLine : public AutomationLine
{
public:
- AutomationPanLine (string name, ARDOUR::Session&, TimeAxisView&, GtkCanvasItem* parent,
+ AutomationPanLine (string name, ARDOUR::Session&, TimeAxisView&, GnomeCanvasItem* parent,
ARDOUR::Curve&,
- gint (*point_callback)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_callback)(GtkCanvasItem*, GdkEvent*, gpointer));
+ gint (*point_callback)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_callback)(GnomeCanvasItem*, GdkEvent*, gpointer));
void view_to_model_y (double&);
void model_to_view_y (double&);
private:
ARDOUR::Session& session;
- vector<GtkCanvasItem*> lines;
+ vector<GnomeCanvasItem*> lines;
};
auto_play_item = 0;
ignore_state_request = false;
- base_rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(canvas_display),
- gtk_canvas_simplerect_get_type(),
+ base_rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(canvas_display),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 1000000.0,
void set_samples_per_unit (double);
std::string name() const { return _name; }
- virtual void add_automation_event (GtkCanvasItem *item, GdkEvent *event, jack_nframes_t, double) = 0;
+ virtual void add_automation_event (GnomeCanvasItem *item, GdkEvent *event, jack_nframes_t, double) = 0;
void clear_lines ();
void add_line (AutomationLine&);
protected:
ARDOUR::Route& route;
- GtkCanvasItem* base_rect;
+ GnomeCanvasItem* base_rect;
string _name;
string _state_name;
bool in_destructor;
-/* gtk-canvas-curve.h: GtkCanvas item for constrained spline curves
+/* libgnomecanvas/gnome-canvas-curve.h: GnomeCanvas item for constrained spline curves
*
* Copyright (C) 2003 Paul Davis <pbd@op.net>
*
*
*/
-#ifndef __GTK_CANVAS_CURVE_H__
-#define __GTK_CANVAS_CURVE_H__
+#ifndef __GNOME_CANVAS_CURVE_H__
+#define __GNOME_CANVAS_CURVE_H__
-#include <gtk-canvas/gtk-canvas-defs.h>
-#include "gtk-canvas/gtk-canvas.h"
+#include <libgnomecanvas/libgnomecanvas.h>
-BEGIN_GTK_CANVAS_DECLS
+BEGIN_GNOME_CANVAS_DECLS
/* Wave viewer item for canvas.
*/
-#define GTK_CANVAS_TYPE_CANVAS_CURVE (gtk_canvas_curve_get_type ())
-#define GTK_CANVAS_CURVE(obj) (GTK_CHECK_CAST ((obj), GTK_CANVAS_TYPE_CANVAS_CURVE, GtkCanvasCurve))
-#define GTK_CANVAS_CURVE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_CANVAS_TYPE_CANVAS_CURVE, GtkCanvasCurveClass))
-#define GTK_CANVAS_IS_CANVAS_CURVE(obj) (GTK_CHECK_TYPE ((obj), GTK_CANVAS_TYPE_CANVAS_CURVE))
-#define GTK_CANVAS_IS_CANVAS_CURVE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_CANVAS_TYPE_CANVAS_CURVE))
+#define GNOME_CANVAS_TYPE_CANVAS_CURVE (gnome_canvas_curve_get_type ())
+#define GNOME_CANVAS_CURVE(obj) (GTK_CHECK_CAST ((obj), GNOME_CANVAS_TYPE_CANVAS_CURVE, GnomeCanvasCurve))
+#define GNOME_CANVAS_CURVE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GNOME_CANVAS_TYPE_CANVAS_CURVE, GnomeCanvasCurveClass))
+#define GNOME_CANVAS_IS_CANVAS_CURVE(obj) (GTK_CHECK_TYPE ((obj), GNOME_CANVAS_TYPE_CANVAS_CURVE))
+#define GNOME_CANVAS_IS_CANVAS_CURVE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GNOME_CANVAS_TYPE_CANVAS_CURVE))
-typedef struct _GtkCanvasCurve GtkCanvasCurve;
-typedef struct _GtkCanvasCurveClass GtkCanvasCurveClass;
+typedef struct _GnomeCanvasCurve GnomeCanvasCurve;
+typedef struct _GnomeCanvasCurveClass GnomeCanvasCurveClass;
-struct _GtkCanvasCurve
+struct _GnomeCanvasCurve
{
- GtkCanvasItem item;
+ GnomeCanvasItem item;
double x1, y1, x2, y2;
void* curve_arg;
float* vector;
guint32 bbox_lrx, bbox_lry;
};
-struct _GtkCanvasCurveClass {
- GtkCanvasItemClass parent_class;
+struct _GnomeCanvasCurveClass {
+ GnomeCanvasItemClass parent_class;
};
-GtkType gtk_canvas_curve_get_type (void);
+GtkType gnome_canvas_curve_get_type (void);
-END_GTK_CANVAS_DECLS
+END_GNOME_CANVAS_DECLS
-#endif /* __GTK_CANVAS_CURVE_H__ */
+#endif /* __GNOME_CANVAS_CURVE_H__ */
-/* Image item type for GtkCanvas widget
+/* Image item type for GnomeCanvas widget
*
- * GtkCanvas is basically a port of the Tk toolkit's most excellent canvas widget. Tk is
+ * GnomeCanvas is basically a port of the Tk toolkit's most excellent canvas widget. Tk is
* copyrighted by the Regents of the University of California, Sun Microsystems, and other parties.
*
* Copyright (C) 1998 The Free Software Foundation
#include "libart_lgpl/art_pixbuf.h"
#include "libart_lgpl/art_rgb_pixbuf_affine.h"
#include "canvas-imageframe.h"
-#include <gtk-canvas/gtk-canvas-util.h>
-#include <gtk-canvas/gtk-canvastypebuiltins.h>
+#include <libgnomecanvas/gnome-canvas-util.h>
+#include <libgnomecanvas/gnome-canvastypebuiltins.h>
enum {
};
-static void gtk_canvas_imageframe_class_init(GtkCanvasImageFrameClass* class) ;
-static void gtk_canvas_imageframe_init(GtkCanvasImageFrame* image) ;
-static void gtk_canvas_imageframe_destroy(GtkObject* object) ;
-static void gtk_canvas_imageframe_set_arg(GtkObject* object, GtkArg* arg, guint arg_id) ;
-static void gtk_canvas_imageframe_get_arg(GtkObject* object, GtkArg* arg, guint arg_id) ;
+static void gnome_canvas_imageframe_class_init(GnomeCanvasImageFrameClass* class) ;
+static void gnome_canvas_imageframe_init(GnomeCanvasImageFrame* image) ;
+static void gnome_canvas_imageframe_destroy(GtkObject* object) ;
+static void gnome_canvas_imageframe_set_arg(GtkObject* object, GtkArg* arg, guint arg_id) ;
+static void gnome_canvas_imageframe_get_arg(GtkObject* object, GtkArg* arg, guint arg_id) ;
-static void gtk_canvas_imageframe_update(GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags) ;
-static void gtk_canvas_imageframe_realize(GtkCanvasItem *item) ;
-static void gtk_canvas_imageframe_unrealize(GtkCanvasItem *item) ;
-static void gtk_canvas_imageframe_draw(GtkCanvasItem *item, GdkDrawable *drawable, int x, int y, int width, int height) ;
-static double gtk_canvas_imageframe_point(GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item) ;
-static void gtk_canvas_imageframe_translate(GtkCanvasItem *item, double dx, double dy) ;
-static void gtk_canvas_imageframe_bounds(GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2) ;
-static void gtk_canvas_imageframe_render(GtkCanvasItem *item, GtkCanvasBuf *buf) ;
+static void gnome_canvas_imageframe_update(GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags) ;
+static void gnome_canvas_imageframe_realize(GnomeCanvasItem *item) ;
+static void gnome_canvas_imageframe_unrealize(GnomeCanvasItem *item) ;
+static void gnome_canvas_imageframe_draw(GnomeCanvasItem *item, GdkDrawable *drawable, int x, int y, int width, int height) ;
+static double gnome_canvas_imageframe_point(GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item) ;
+static void gnome_canvas_imageframe_translate(GnomeCanvasItem *item, double dx, double dy) ;
+static void gnome_canvas_imageframe_bounds(GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2) ;
+static void gnome_canvas_imageframe_render(GnomeCanvasItem *item, GnomeCanvasBuf *buf) ;
-static GtkCanvasItemClass *parent_class;
+static GnomeCanvasItemClass *parent_class;
GtkType
-gtk_canvas_imageframe_get_type (void)
+gnome_canvas_imageframe_get_type (void)
{
static GtkType imageframe_type = 0;
if (!imageframe_type) {
GtkTypeInfo imageframe_info = {
- "GtkCanvasImageFrame",
- sizeof (GtkCanvasImageFrame),
- sizeof (GtkCanvasImageFrameClass),
- (GtkClassInitFunc) gtk_canvas_imageframe_class_init,
- (GtkObjectInitFunc) gtk_canvas_imageframe_init,
+ "GnomeCanvasImageFrame",
+ sizeof (GnomeCanvasImageFrame),
+ sizeof (GnomeCanvasImageFrameClass),
+ (GtkClassInitFunc) gnome_canvas_imageframe_class_init,
+ (GtkObjectInitFunc) gnome_canvas_imageframe_init,
NULL, /* reserved_1 */
NULL, /* reserved_2 */
(GtkClassInitFunc) NULL
};
- imageframe_type = gtk_type_unique (gtk_canvas_item_get_type (), &imageframe_info);
+ imageframe_type = gtk_type_unique (gnome_canvas_item_get_type (), &imageframe_info);
}
return imageframe_type;
}
static void
-gtk_canvas_imageframe_class_init (GtkCanvasImageFrameClass *class)
+gnome_canvas_imageframe_class_init (GnomeCanvasImageFrameClass *class)
{
GtkObjectClass *object_class;
- GtkCanvasItemClass *item_class;
+ GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass *) class;
- item_class = (GtkCanvasItemClass *) class;
-
- parent_class = gtk_type_class (gtk_canvas_item_get_type ());
-
- gtk_object_add_arg_type ("GtkCanvasImageFrame::pixbuf", GTK_TYPE_BOXED, GTK_ARG_WRITABLE, ARG_PIXBUF);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::x", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::y", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::width", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_WIDTH);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::drawwidth", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_DRAWWIDTH);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::height", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_HEIGHT);
- gtk_object_add_arg_type ("GtkCanvasImageFrame::anchor", GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, ARG_ANCHOR);
-
- object_class->destroy = gtk_canvas_imageframe_destroy;
- object_class->set_arg = gtk_canvas_imageframe_set_arg;
- object_class->get_arg = gtk_canvas_imageframe_get_arg;
-
- item_class->update = gtk_canvas_imageframe_update;
- item_class->realize = gtk_canvas_imageframe_realize;
- item_class->unrealize = gtk_canvas_imageframe_unrealize;
- item_class->draw = gtk_canvas_imageframe_draw;
- item_class->point = gtk_canvas_imageframe_point;
- item_class->translate = gtk_canvas_imageframe_translate;
- item_class->bounds = gtk_canvas_imageframe_bounds;
- item_class->render = gtk_canvas_imageframe_render;
+ item_class = (GnomeCanvasItemClass *) class;
+
+ parent_class = gtk_type_class (gnome_canvas_item_get_type ());
+
+ gtk_object_add_arg_type ("GnomeCanvasImageFrame::pixbuf", GTK_TYPE_BOXED, GTK_ARG_WRITABLE, ARG_PIXBUF);
+ gtk_object_add_arg_type ("GnomeCanvasImageFrame::x", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X);
+ gtk_object_add_arg_type ("GnomeCanvasImageFrame::y", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y);
+ gtk_object_add_arg_type ("GnomeCanvasImageFrame::width", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_WIDTH);
+ gtk_object_add_arg_type ("GnomeCanvasImageFrame::drawwidth", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_DRAWWIDTH);
+ gtk_object_add_arg_type ("GnomeCanvasImageFrame::height", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_HEIGHT);
+ gtk_object_add_arg_type ("GnomeCanvasImageFrame::anchor", GTK_TYPE_ANCHOR_TYPE, GTK_ARG_READWRITE, ARG_ANCHOR);
+
+ object_class->destroy = gnome_canvas_imageframe_destroy;
+ object_class->set_arg = gnome_canvas_imageframe_set_arg;
+ object_class->get_arg = gnome_canvas_imageframe_get_arg;
+
+ item_class->update = gnome_canvas_imageframe_update;
+ item_class->realize = gnome_canvas_imageframe_realize;
+ item_class->unrealize = gnome_canvas_imageframe_unrealize;
+ item_class->draw = gnome_canvas_imageframe_draw;
+ item_class->point = gnome_canvas_imageframe_point;
+ item_class->translate = gnome_canvas_imageframe_translate;
+ item_class->bounds = gnome_canvas_imageframe_bounds;
+ item_class->render = gnome_canvas_imageframe_render;
}
static void
-gtk_canvas_imageframe_init (GtkCanvasImageFrame *image)
+gnome_canvas_imageframe_init (GnomeCanvasImageFrame *image)
{
image->x = 0.0;
image->y = 0.0;
image->height = 0.0;
image->drawwidth = 0.0;
image->anchor = GTK_ANCHOR_CENTER;
- GTK_CANVAS_ITEM(image)->object.flags |= GTK_CANVAS_ITEM_NO_AUTO_REDRAW;
+ GNOME_CANVAS_ITEM(image)->object.flags |= GNOME_CANVAS_ITEM_NO_AUTO_REDRAW;
}
static void
-gtk_canvas_imageframe_destroy (GtkObject *object)
+gnome_canvas_imageframe_destroy (GtkObject *object)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
g_return_if_fail (object != NULL);
- g_return_if_fail (GTK_CANVAS_IS_CANVAS_IMAGEFRAME (object));
+ g_return_if_fail (GNOME_CANVAS_IS_CANVAS_IMAGEFRAME (object));
- image = GTK_CANVAS_IMAGEFRAME (object);
+ image = GNOME_CANVAS_IMAGEFRAME (object);
image->cwidth = 0;
image->cheight = 0;
/* Get's the image bounds expressed as item-relative coordinates. */
static void
-get_bounds_item_relative (GtkCanvasImageFrame *image, double *px1, double *py1, double *px2, double *py2)
+get_bounds_item_relative (GnomeCanvasImageFrame *image, double *px1, double *py1, double *px2, double *py2)
{
- GtkCanvasItem *item;
+ GnomeCanvasItem *item;
double x, y;
- item = GTK_CANVAS_ITEM (image);
+ item = GNOME_CANVAS_ITEM (image);
/* Get item coordinates */
}
static void
-get_bounds (GtkCanvasImageFrame *image, double *px1, double *py1, double *px2, double *py2)
+get_bounds (GnomeCanvasImageFrame *image, double *px1, double *py1, double *px2, double *py2)
{
- GtkCanvasItem *item;
+ GnomeCanvasItem *item;
double i2c[6];
ArtDRect i_bbox, c_bbox;
- item = GTK_CANVAS_ITEM (image);
+ item = GNOME_CANVAS_ITEM (image);
- gtk_canvas_item_i2c_affine (item, i2c);
+ gnome_canvas_item_i2c_affine (item, i2c);
get_bounds_item_relative (image, &i_bbox.x0, &i_bbox.y0, &i_bbox.x1, &i_bbox.y1);
art_drect_affine_transform (&c_bbox, &i_bbox, i2c);
/* deprecated */
static void
-recalc_bounds (GtkCanvasImageFrame *image)
+recalc_bounds (GnomeCanvasImageFrame *image)
{
- GtkCanvasItem *item;
+ GnomeCanvasItem *item;
- item = GTK_CANVAS_ITEM (image);
+ item = GNOME_CANVAS_ITEM (image);
get_bounds (image, &item->x1, &item->y1, &item->x2, &item->y2);
item->x2 = image->cx + image->cwidth;
item->y2 = image->cy + image->cheight;
- gtk_canvas_group_child_bounds (GTK_CANVAS_GROUP (item->parent), item);
+ gnome_canvas_group_child_bounds (GNOME_CANVAS_GROUP (item->parent), item);
}
static void
-gtk_canvas_imageframe_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_imageframe_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasItem *item;
- GtkCanvasImageFrame *image;
+ GnomeCanvasItem *item;
+ GnomeCanvasImageFrame *image;
int update;
int calc_bounds;
- item = GTK_CANVAS_ITEM (object);
- image = GTK_CANVAS_IMAGEFRAME (object);
+ item = GNOME_CANVAS_ITEM (object);
+ image = GNOME_CANVAS_IMAGEFRAME (object);
update = FALSE;
calc_bounds = FALSE;
#ifdef OLD_XFORM
if (update)
- (* GTK_CANVAS_ITEM_CLASS (item->object.klass)->update) (item, NULL, NULL, 0);
+ (* GNOME_CANVAS_ITEM_CLASS (item->object.klass)->update) (item, NULL, NULL, 0);
if (calc_bounds)
recalc_bounds (image);
#else
if (update)
- gtk_canvas_item_request_update (item);
+ gnome_canvas_item_request_update (item);
#endif
}
static void
-gtk_canvas_imageframe_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_imageframe_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME (object);
+ image = GNOME_CANVAS_IMAGEFRAME (object);
switch (arg_id) {
}
static void
-gtk_canvas_imageframe_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
+gnome_canvas_imageframe_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
ArtDRect i_bbox, c_bbox;
int w = 0;
int h = 0;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
if (parent_class->update)
(* parent_class->update) (item, affine, clip_path, flags);
c_bbox.x1++;
c_bbox.y1++;
- gtk_canvas_update_bbox (item, c_bbox.x0, c_bbox.y0, c_bbox.x1, c_bbox.y1);
+ gnome_canvas_update_bbox (item, c_bbox.x0, c_bbox.y0, c_bbox.x1, c_bbox.y1);
if (image->pixbuf) {
w = image->pixbuf->width;
}
static void
-gtk_canvas_imageframe_realize (GtkCanvasItem *item)
+gnome_canvas_imageframe_realize (GnomeCanvasItem *item)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
if (parent_class->realize)
(* parent_class->realize) (item);
}
static void
-gtk_canvas_imageframe_unrealize (GtkCanvasItem *item)
+gnome_canvas_imageframe_unrealize (GnomeCanvasItem *item)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME(item);
+ image = GNOME_CANVAS_IMAGEFRAME(item);
if (parent_class->unrealize)
(* parent_class->unrealize) (item);
}
static void
-recalc_if_needed (GtkCanvasImageFrame *image)
+recalc_if_needed (GnomeCanvasImageFrame *image)
{}
static void
-gtk_canvas_imageframe_draw (GtkCanvasItem *item, GdkDrawable *drawable,
+gnome_canvas_imageframe_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
int x, int y, int width, int height)
{
fprintf(stderr, "please don't use the CanvasImageFrame item in a non-aa Canvas\n") ;
}
static double
-gtk_canvas_imageframe_point (GtkCanvasItem *item, double x, double y,
- int cx, int cy, GtkCanvasItem **actual_item)
+gnome_canvas_imageframe_point (GnomeCanvasItem *item, double x, double y,
+ int cx, int cy, GnomeCanvasItem **actual_item)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
int x1, y1, x2, y2;
int dx, dy;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
*actual_item = item;
}
static void
-gtk_canvas_imageframe_translate (GtkCanvasItem *item, double dx, double dy)
+gnome_canvas_imageframe_translate (GnomeCanvasItem *item, double dx, double dy)
{
#ifdef OLD_XFORM
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
image->x += dx;
image->y += dy;
}
static void
-gtk_canvas_imageframe_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+gnome_canvas_imageframe_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
*x1 = image->x;
*y1 = image->y;
}
static void
-gtk_canvas_imageframe_render (GtkCanvasItem *item, GtkCanvasBuf *buf)
+gnome_canvas_imageframe_render (GnomeCanvasItem *item, GnomeCanvasBuf *buf)
{
- GtkCanvasImageFrame *image;
+ GnomeCanvasImageFrame *image;
- image = GTK_CANVAS_IMAGEFRAME (item);
+ image = GNOME_CANVAS_IMAGEFRAME (item);
- gtk_canvas_buf_ensure_buf (buf);
+ gnome_canvas_buf_ensure_buf (buf);
#ifdef VERBOSE
{
char str[128];
art_affine_to_string (str, image->affine);
- g_print ("gtk_canvas_imageframe_render %s\n", str);
+ g_print ("gnome_canvas_imageframe_render %s\n", str);
}
#endif
-/* Image item type for GtkCanvas widget
+/* Image item type for GnomeCanvas widget
*
- * GtkCanvas is basically a port of the Tk toolkit's most excellent canvas widget. Tk is
+ * GnomeCanvas is basically a port of the Tk toolkit's most excellent canvas widget. Tk is
* copyrighted by the Regents of the University of California, Sun Microsystems, and other parties.
*
* Copyright (C) 1998 The Free Software Foundation
*/
-#ifndef __GTK_CANVAS_IMAGEFRAME_H__
-#define __GTK_CANVAS_IMAGEFRAME_H__
+#ifndef __GNOME_CANVAS_IMAGEFRAME_H__
+#define __GNOME_CANVAS_IMAGEFRAME_H__
#include <stdint.h>
-#include <gtk-canvas/gtk-canvas-defs.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <gtk/gtkpacker.h> /* why the hell is GtkAnchorType here and not in gtkenums.h? */
#include <libart_lgpl/art_misc.h>
#include <libart_lgpl/art_pixbuf.h>
-#include "gtk-canvas/gtk-canvas.h"
-BEGIN_GTK_CANVAS_DECLS
+BEGIN_GNOME_CANVAS_DECLS
/* Image item for the canvas. Images are positioned by anchoring them to a point.
*/
-#define GTK_CANVAS_TYPE_CANVAS_IMAGEFRAME (gtk_canvas_imageframe_get_type ())
-#define GTK_CANVAS_IMAGEFRAME(obj) (GTK_CHECK_CAST ((obj), GTK_CANVAS_TYPE_CANVAS_IMAGEFRAME, GtkCanvasImageFrame))
-#define GTK_CANVAS_IMAGEFRAME_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_CANVAS_TYPE_CANVAS_IMAGEFRAME, GtkCanvasImageFrameClass))
-#define GTK_CANVAS_IS_CANVAS_IMAGEFRAME(obj) (GTK_CHECK_TYPE ((obj), GTK_CANVAS_TYPE_CANVAS_IMAGEFRAME))
-#define GTK_CANVAS_IS_CANVAS_IMAGEFRAME_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_CANVAS_TYPE_CANVAS_IMAGEFRAME))
+#define GNOME_CANVAS_TYPE_CANVAS_IMAGEFRAME (gnome_canvas_imageframe_get_type ())
+#define GNOME_CANVAS_IMAGEFRAME(obj) (GTK_CHECK_CAST ((obj), GNOME_CANVAS_TYPE_CANVAS_IMAGEFRAME, GnomeCanvasImageFrame))
+#define GNOME_CANVAS_IMAGEFRAME_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GNOME_CANVAS_TYPE_CANVAS_IMAGEFRAME, GnomeCanvasImageFrameClass))
+#define GNOME_CANVAS_IS_CANVAS_IMAGEFRAME(obj) (GTK_CHECK_TYPE ((obj), GNOME_CANVAS_TYPE_CANVAS_IMAGEFRAME))
+#define GNOME_CANVAS_IS_CANVAS_IMAGEFRAME_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GNOME_CANVAS_TYPE_CANVAS_IMAGEFRAME))
-typedef struct _GtkCanvasImageFrame GtkCanvasImageFrame;
-typedef struct _GtkCanvasImageFrameClass GtkCanvasImageFrameClass;
+typedef struct _GnomeCanvasImageFrame GnomeCanvasImageFrame;
+typedef struct _GnomeCanvasImageFrameClass GnomeCanvasImageFrameClass;
-struct _GtkCanvasImageFrame {
- GtkCanvasItem item;
+struct _GnomeCanvasImageFrame {
+ GnomeCanvasItem item;
double x, y; /* Position at anchor, item relative */
double width, height; /* Size of image, item relative */
double affine[6]; /* The item -> canvas affine */
};
-struct _GtkCanvasImageFrameClass {
- GtkCanvasItemClass parent_class;
+struct _GnomeCanvasImageFrameClass {
+ GnomeCanvasItemClass parent_class;
};
/* Standard Gtk function */
-GtkType gtk_canvas_imageframe_get_type (void);
+GtkType gnome_canvas_imageframe_get_type (void);
-END_GTK_CANVAS_DECLS
+END_GNOME_CANVAS_DECLS
#endif
#include <stdio.h>
#include <math.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include "canvas-ruler.h"
#include "rgb_macros.h"
};
-static void gtk_canvas_ruler_class_init (GtkCanvasRulerClass *class);
-static void gtk_canvas_ruler_init (GtkCanvasRuler *ruler);
-static void gtk_canvas_ruler_set_arg (GtkObject *object,
+static void gnome_canvas_ruler_class_init (GnomeCanvasRulerClass *class);
+static void gnome_canvas_ruler_init (GnomeCanvasRuler *ruler);
+static void gnome_canvas_ruler_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_canvas_ruler_get_arg (GtkObject *object,
+static void gnome_canvas_ruler_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_canvas_ruler_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags);
-static void gtk_canvas_ruler_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2);
-static double gtk_canvas_ruler_point (GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item);
-static void gtk_canvas_ruler_render (GtkCanvasItem *item, GtkCanvasBuf *buf);
-static void gtk_canvas_ruler_draw (GtkCanvasItem *item, GdkDrawable *drawable, int x, int y, int w, int h);
+static void gnome_canvas_ruler_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags);
+static void gnome_canvas_ruler_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2);
+static double gnome_canvas_ruler_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item);
+static void gnome_canvas_ruler_render (GnomeCanvasItem *item, GnomeCanvasBuf *buf);
+static void gnome_canvas_ruler_draw (GnomeCanvasItem *item, GdkDrawable *drawable, int x, int y, int w, int h);
-static GtkCanvasItemClass *parent_class;
+static GnomeCanvasItemClass *parent_class;
GtkType
-gtk_canvas_ruler_get_type (void)
+gnome_canvas_ruler_get_type (void)
{
static GtkType ruler_type = 0;
if (!ruler_type) {
GtkTypeInfo ruler_info = {
- "GtkCanvasRuler",
- sizeof (GtkCanvasRuler),
- sizeof (GtkCanvasRulerClass),
- (GtkClassInitFunc) gtk_canvas_ruler_class_init,
- (GtkObjectInitFunc) gtk_canvas_ruler_init,
+ "GnomeCanvasRuler",
+ sizeof (GnomeCanvasRuler),
+ sizeof (GnomeCanvasRulerClass),
+ (GtkClassInitFunc) gnome_canvas_ruler_class_init,
+ (GtkObjectInitFunc) gnome_canvas_ruler_init,
NULL, /* reserved_1 */
NULL, /* reserved_2 */
(GtkClassInitFunc) NULL
};
- ruler_type = gtk_type_unique (gtk_canvas_item_get_type (), &ruler_info);
+ ruler_type = gtk_type_unique (gnome_canvas_item_get_type (), &ruler_info);
}
return ruler_type;
}
static void
-gtk_canvas_ruler_class_init (GtkCanvasRulerClass *class)
+gnome_canvas_ruler_class_init (GnomeCanvasRulerClass *class)
{
GtkObjectClass *object_class;
- GtkCanvasItemClass *item_class;
+ GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass *) class;
- item_class = (GtkCanvasItemClass *) class;
-
- parent_class = gtk_type_class (gtk_canvas_item_get_type ());
-
- gtk_object_add_arg_type ("GtkCanvasRuler::x1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X1);
- gtk_object_add_arg_type ("GtkCanvasRuler::y1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y1);
- gtk_object_add_arg_type ("GtkCanvasRuler::x2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X2);
- gtk_object_add_arg_type ("GtkCanvasRuler::y2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y2);
- gtk_object_add_arg_type ("GtkCanvasRuler::frames_per_unit", GTK_TYPE_LONG, GTK_ARG_READWRITE, ARG_FRAMES_PER_UNIT);
- gtk_object_add_arg_type ("GtkCanvasRuler::fill_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_FILL_COLOR);
- gtk_object_add_arg_type ("GtkCanvasRuler::tick_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_TICK_COLOR);
-
- object_class->set_arg = gtk_canvas_ruler_set_arg;
- object_class->get_arg = gtk_canvas_ruler_get_arg;
-
- item_class->update = gtk_canvas_ruler_update;
- item_class->bounds = gtk_canvas_ruler_bounds;
- item_class->point = gtk_canvas_ruler_point;
- item_class->render = gtk_canvas_ruler_render;
- item_class->draw = gtk_canvas_ruler_draw;
+ item_class = (GnomeCanvasItemClass *) class;
+
+ parent_class = gtk_type_class (gnome_canvas_item_get_type ());
+
+ gtk_object_add_arg_type ("GnomeCanvasRuler::x1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X1);
+ gtk_object_add_arg_type ("GnomeCanvasRuler::y1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y1);
+ gtk_object_add_arg_type ("GnomeCanvasRuler::x2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X2);
+ gtk_object_add_arg_type ("GnomeCanvasRuler::y2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y2);
+ gtk_object_add_arg_type ("GnomeCanvasRuler::frames_per_unit", GTK_TYPE_LONG, GTK_ARG_READWRITE, ARG_FRAMES_PER_UNIT);
+ gtk_object_add_arg_type ("GnomeCanvasRuler::fill_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_FILL_COLOR);
+ gtk_object_add_arg_type ("GnomeCanvasRuler::tick_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_TICK_COLOR);
+
+ object_class->set_arg = gnome_canvas_ruler_set_arg;
+ object_class->get_arg = gnome_canvas_ruler_get_arg;
+
+ item_class->update = gnome_canvas_ruler_update;
+ item_class->bounds = gnome_canvas_ruler_bounds;
+ item_class->point = gnome_canvas_ruler_point;
+ item_class->render = gnome_canvas_ruler_render;
+ item_class->draw = gnome_canvas_ruler_draw;
}
static void
-gtk_canvas_ruler_init (GtkCanvasRuler *ruler)
+gnome_canvas_ruler_init (GnomeCanvasRuler *ruler)
{
ruler->x1 = 0.0;
ruler->y1 = 0.0;
ruler->fill_color = 0;
ruler->tick_color = 0;
- GTK_CANVAS_ITEM(ruler)->object.flags |= GTK_CANVAS_ITEM_NO_AUTO_REDRAW;
+ GNOME_CANVAS_ITEM(ruler)->object.flags |= GNOME_CANVAS_ITEM_NO_AUTO_REDRAW;
}
static void
-gtk_canvas_ruler_reset_bounds (GtkCanvasItem *item)
+gnome_canvas_ruler_reset_bounds (GnomeCanvasItem *item)
{
double x1, x2, y1, y2;
int Ix1, Ix2, Iy1, Iy2;
double i2w[6];
- gtk_canvas_ruler_bounds (item, &x1, &y1, &x2, &y2);
+ gnome_canvas_ruler_bounds (item, &x1, &y1, &x2, &y2);
i1.x = x1;
i1.y = y1;
i2.x = x2;
i2.y = y2;
- gtk_canvas_item_i2w_affine (item, i2w);
+ gnome_canvas_item_i2w_affine (item, i2w);
art_affine_point (&w1, &i1, i2w);
art_affine_point (&w2, &i2, i2w);
Iy1 = (int) rint(w1.y);
Iy2 = (int) rint(w2.y);
- gtk_canvas_update_bbox (item, Ix1, Iy1, Ix2, Iy2);
+ gnome_canvas_update_bbox (item, Ix1, Iy1, Ix2, Iy2);
}
/*
*/
static void
-gtk_canvas_ruler_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_ruler_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasItem *item;
- GtkCanvasRuler *ruler;
+ GnomeCanvasItem *item;
+ GnomeCanvasRuler *ruler;
int redraw;
int calc_bounds;
- item = GTK_CANVAS_ITEM (object);
- ruler = GTK_CANVAS_RULER (object);
+ item = GNOME_CANVAS_ITEM (object);
+ ruler = GNOME_CANVAS_RULER (object);
redraw = FALSE;
calc_bounds = FALSE;
}
if (calc_bounds) {
- gtk_canvas_ruler_reset_bounds (item);
+ gnome_canvas_ruler_reset_bounds (item);
}
if (redraw) {
- gtk_canvas_item_request_update (item);
+ gnome_canvas_item_request_update (item);
}
}
static void
-gtk_canvas_ruler_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_ruler_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasRuler *ruler;
+ GnomeCanvasRuler *ruler;
- ruler = GTK_CANVAS_RULER (object);
+ ruler = GNOME_CANVAS_RULER (object);
switch (arg_id) {
case ARG_X1:
}
static void
-gtk_canvas_ruler_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
+gnome_canvas_ruler_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
{
- GtkCanvasRuler *ruler;
+ GnomeCanvasRuler *ruler;
double x;
double y;
- ruler = GTK_CANVAS_RULER (item);
+ ruler = GNOME_CANVAS_RULER (item);
if (parent_class->update)
(* parent_class->update) (item, affine, clip_path, flags);
- gtk_canvas_ruler_reset_bounds (item);
+ gnome_canvas_ruler_reset_bounds (item);
x = ruler->x1;
y = ruler->y1;
- gtk_canvas_item_i2w (item, &x, &y);
- gtk_canvas_w2c (GTK_CANVAS(item->canvas), x, y, &ruler->bbox_ulx, &ruler->bbox_uly);
+ gnome_canvas_item_i2w (item, &x, &y);
+ gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &ruler->bbox_ulx, &ruler->bbox_uly);
x = ruler->x2;
y = ruler->y2;
- gtk_canvas_item_i2w (item, &x, &y);
- gtk_canvas_w2c (GTK_CANVAS(item->canvas), x, y, &ruler->bbox_lrx, &ruler->bbox_lry);
+ gnome_canvas_item_i2w (item, &x, &y);
+ gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &ruler->bbox_lrx, &ruler->bbox_lry);
UINT_TO_RGB (ruler->tick_color, &ruler->tick_r, &ruler->tick_g, &ruler->tick_b);
UINT_TO_RGB (ruler->fill_color, &ruler->fill_r, &ruler->fill_g, &ruler->fill_b);
}
static void
-gtk_canvas_ruler_render (GtkCanvasItem *item,
- GtkCanvasBuf *buf)
+gnome_canvas_ruler_render (GnomeCanvasItem *item,
+ GnomeCanvasBuf *buf)
{
- GtkCanvasRuler *ruler;
+ GnomeCanvasRuler *ruler;
int end, begin;
- ruler = GTK_CANVAS_RULER (item);
+ ruler = GNOME_CANVAS_RULER (item);
if (parent_class->render) {
(*parent_class->render) (item, buf);
}
if (buf->is_bg) {
- gtk_canvas_buf_ensure_buf (buf);
+ gnome_canvas_buf_ensure_buf (buf);
buf->is_bg = FALSE;
}
}
static void
-gtk_canvas_ruler_draw (GtkCanvasItem *item,
+gnome_canvas_ruler_draw (GnomeCanvasItem *item,
GdkDrawable *drawable,
int x, int y,
int width, int height)
{
- GtkCanvasRuler *ruler;
+ GnomeCanvasRuler *ruler;
- ruler = GTK_CANVAS_RULER (item);
+ ruler = GNOME_CANVAS_RULER (item);
if (parent_class->draw) {
(* parent_class->draw) (item, drawable, x, y, width, height);
}
static void
-gtk_canvas_ruler_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+gnome_canvas_ruler_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
{
- GtkCanvasRuler *ruler = GTK_CANVAS_RULER (item);
+ GnomeCanvasRuler *ruler = GNOME_CANVAS_RULER (item);
*x1 = ruler->x1;
*y1 = ruler->y1;
}
static double
-gtk_canvas_ruler_point (GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item)
+gnome_canvas_ruler_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
{
- GtkCanvasRuler *ruler;
+ GnomeCanvasRuler *ruler;
double x1, y1, x2, y2;
double dx, dy;
- ruler = GTK_CANVAS_RULER (item);
+ ruler = GNOME_CANVAS_RULER (item);
*actual_item = item;
/* Find the bounds for the rectangle plus its outline width */
- gtk_canvas_ruler_bounds (item, &x1, &y1, &x2, &y2);
+ gnome_canvas_ruler_bounds (item, &x1, &y1, &x2, &y2);
/* Is point inside rectangle */
-/* gtk-canvas-ruler.h: GtkCanvas item for simple rects
+/* libgnomecanvas/gnome-canvas-ruler.h: GnomeCanvas item for simple rects
*
* Copyright (C) 2001 Paul Davis <pbd@op.net>
*
*
*/
-#ifndef __GTK_CANVAS_RULER_H__
-#define __GTK_CANVAS_RULER_H__
+#ifndef __GNOME_CANVAS_RULER_H__
+#define __GNOME_CANVAS_RULER_H__
#include <stdint.h>
-#include <gtk-canvas/gtk-canvas-defs.h>
-#include "gtk-canvas/gtk-canvas.h"
+#include "libgnomecanvas/libgnomecanvas.h"
-BEGIN_GTK_CANVAS_DECLS
+BEGIN_GNOME_CANVAS_DECLS
/* Wave viewer item for canvas.
*/
-#define GTK_CANVAS_TYPE_CANVAS_RULER (gtk_canvas_ruler_get_type ())
-#define GTK_CANVAS_RULER(obj) (GTK_CHECK_CAST ((obj), GTK_CANVAS_TYPE_CANVAS_RULER, GtkCanvasRuler))
-#define GTK_CANVAS_RULER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_CANVAS_TYPE_CANVAS_RULER, GtkCanvasRulerClass))
-#define GTK_CANVAS_IS_CANVAS_RULER(obj) (GTK_CHECK_TYPE ((obj), GTK_CANVAS_TYPE_CANVAS_RULER))
-#define GTK_CANVAS_IS_CANVAS_RULER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_CANVAS_TYPE_CANVAS_RULER))
+#define GNOME_CANVAS_TYPE_CANVAS_RULER (gnome_canvas_ruler_get_type ())
+#define GNOME_CANVAS_RULER(obj) (GTK_CHECK_CAST ((obj), GNOME_CANVAS_TYPE_CANVAS_RULER, GnomeCanvasRuler))
+#define GNOME_CANVAS_RULER_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GNOME_CANVAS_TYPE_CANVAS_RULER, GnomeCanvasRulerClass))
+#define GNOME_CANVAS_IS_CANVAS_RULER(obj) (GTK_CHECK_TYPE ((obj), GNOME_CANVAS_TYPE_CANVAS_RULER))
+#define GNOME_CANVAS_IS_CANVAS_RULER_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GNOME_CANVAS_TYPE_CANVAS_RULER))
-typedef struct _GtkCanvasRuler GtkCanvasRuler;
-typedef struct _GtkCanvasRulerClass GtkCanvasRulerClass;
+typedef struct _GnomeCanvasRuler GnomeCanvasRuler;
+typedef struct _GnomeCanvasRulerClass GnomeCanvasRulerClass;
-struct _GtkCanvasRuler
+struct _GnomeCanvasRuler
{
- GtkCanvasItem item;
+ GnomeCanvasItem item;
double x1, y1, x2, y2;
uint32_t fill_color;
uint32_t tick_color;
guint32 bbox_lrx, bbox_lry;
};
-struct _GtkCanvasRulerClass {
- GtkCanvasItemClass parent_class;
+struct _GnomeCanvasRulerClass {
+ GnomeCanvasItemClass parent_class;
};
-GtkType gtk_canvas_ruler_get_type (void);
+GtkType gnome_canvas_ruler_get_type (void);
-END_GTK_CANVAS_DECLS
+END_GNOME_CANVAS_DECLS
-#endif /* __GTK_CANVAS_RULER_H__ */
+#endif /* __GNOME_CANVAS_RULER_H__ */
#include <stdio.h>
#include <math.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include "canvas-simpleline.h"
#include "rgb_macros.h"
ARG_COLOR_RGBA
};
-static void gtk_canvas_simpleline_class_init (GtkCanvasSimpleLineClass *class);
-static void gtk_canvas_simpleline_init (GtkCanvasSimpleLine *simpleline);
-static void gtk_canvas_simpleline_set_arg (GtkObject *object,
+static void gnome_canvas_simpleline_class_init (GnomeCanvasSimpleLineClass *class);
+static void gnome_canvas_simpleline_init (GnomeCanvasSimpleLine *simpleline);
+static void gnome_canvas_simpleline_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_canvas_simpleline_get_arg (GtkObject *object,
+static void gnome_canvas_simpleline_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_canvas_simpleline_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags);
-static void gtk_canvas_simpleline_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2);
-static double gtk_canvas_simpleline_point (GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item);
-static void gtk_canvas_simpleline_render (GtkCanvasItem *item, GtkCanvasBuf *buf);
-static void gtk_canvas_simpleline_draw (GtkCanvasItem *item, GdkDrawable *drawable, int x, int y, int w, int h);
+static void gnome_canvas_simpleline_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags);
+static void gnome_canvas_simpleline_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2);
+static double gnome_canvas_simpleline_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item);
+static void gnome_canvas_simpleline_render (GnomeCanvasItem *item, GnomeCanvasBuf *buf);
+static void gnome_canvas_simpleline_draw (GnomeCanvasItem *item, GdkDrawable *drawable, int x, int y, int w, int h);
-static GtkCanvasItemClass *parent_class;
+static GnomeCanvasItemClass *parent_class;
GtkType
-gtk_canvas_simpleline_get_type (void)
+gnome_canvas_simpleline_get_type (void)
{
static GtkType simpleline_type = 0;
if (!simpleline_type) {
GtkTypeInfo simpleline_info = {
- "GtkCanvasSimpleLine",
- sizeof (GtkCanvasSimpleLine),
- sizeof (GtkCanvasSimpleLineClass),
- (GtkClassInitFunc) gtk_canvas_simpleline_class_init,
- (GtkObjectInitFunc) gtk_canvas_simpleline_init,
+ "GnomeCanvasSimpleLine",
+ sizeof (GnomeCanvasSimpleLine),
+ sizeof (GnomeCanvasSimpleLineClass),
+ (GtkClassInitFunc) gnome_canvas_simpleline_class_init,
+ (GtkObjectInitFunc) gnome_canvas_simpleline_init,
NULL, /* reserved_1 */
NULL, /* reserved_2 */
(GtkClassInitFunc) NULL
};
- simpleline_type = gtk_type_unique (gtk_canvas_item_get_type (), &simpleline_info);
+ simpleline_type = gtk_type_unique (gnome_canvas_item_get_type (), &simpleline_info);
}
return simpleline_type;
}
static void
-gtk_canvas_simpleline_class_init (GtkCanvasSimpleLineClass *class)
+gnome_canvas_simpleline_class_init (GnomeCanvasSimpleLineClass *class)
{
GtkObjectClass *object_class;
- GtkCanvasItemClass *item_class;
+ GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass *) class;
- item_class = (GtkCanvasItemClass *) class;
+ item_class = (GnomeCanvasItemClass *) class;
- parent_class = gtk_type_class (gtk_canvas_item_get_type ());
+ parent_class = gtk_type_class (gnome_canvas_item_get_type ());
- gtk_object_add_arg_type ("GtkCanvasSimpleLine::x1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X1);
- gtk_object_add_arg_type ("GtkCanvasSimpleLine::y1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y1);
- gtk_object_add_arg_type ("GtkCanvasSimpleLine::x2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X2);
- gtk_object_add_arg_type ("GtkCanvasSimpleLine::y2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y2);
- gtk_object_add_arg_type ("GtkCanvasSimpleLine::color_rgba", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_COLOR_RGBA);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleLine::x1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X1);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleLine::y1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y1);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleLine::x2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X2);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleLine::y2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y2);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleLine::color_rgba", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_COLOR_RGBA);
- object_class->set_arg = gtk_canvas_simpleline_set_arg;
- object_class->get_arg = gtk_canvas_simpleline_get_arg;
+ object_class->set_arg = gnome_canvas_simpleline_set_arg;
+ object_class->get_arg = gnome_canvas_simpleline_get_arg;
- item_class->update = gtk_canvas_simpleline_update;
- item_class->bounds = gtk_canvas_simpleline_bounds;
- item_class->point = gtk_canvas_simpleline_point;
- item_class->render = gtk_canvas_simpleline_render;
- item_class->draw = gtk_canvas_simpleline_draw;
+ item_class->update = gnome_canvas_simpleline_update;
+ item_class->bounds = gnome_canvas_simpleline_bounds;
+ item_class->point = gnome_canvas_simpleline_point;
+ item_class->render = gnome_canvas_simpleline_render;
+ item_class->draw = gnome_canvas_simpleline_draw;
}
static void
-gtk_canvas_simpleline_init (GtkCanvasSimpleLine *simpleline)
+gnome_canvas_simpleline_init (GnomeCanvasSimpleLine *simpleline)
{
simpleline->x1 = 0.0;
simpleline->y1 = 0.0;
simpleline->y2 = 0.0;
simpleline->color = RGBA_TO_UINT(98,123,174,241);
simpleline->horizontal = TRUE; /* reset in the _update() method */
- GTK_CANVAS_ITEM(simpleline)->object.flags |= GTK_CANVAS_ITEM_NO_AUTO_REDRAW;
+ GNOME_CANVAS_ITEM(simpleline)->object.flags |= GNOME_CANVAS_ITEM_NO_AUTO_REDRAW;
}
static void
-gtk_canvas_simpleline_bounds_world (GtkCanvasItem *item, int* ix1, int* iy1, int* ix2, int* iy2)
+gnome_canvas_simpleline_bounds_world (GnomeCanvasItem *item, int* ix1, int* iy1, int* ix2, int* iy2)
{
double x1, x2, y1, y2;
ArtPoint i1, i2;
ArtPoint w1, w2;
double i2w[6];
- GtkCanvasSimpleLine *simpleline = GTK_CANVAS_SIMPLELINE(item);
+ GnomeCanvasSimpleLine *simpleline = GNOME_CANVAS_SIMPLELINE(item);
- gtk_canvas_simpleline_bounds (item, &x1, &y1, &x2, &y2);
+ gnome_canvas_simpleline_bounds (item, &x1, &y1, &x2, &y2);
i1.x = x1;
i1.y = y1;
i2.x = x2;
i2.y = y2;
- gtk_canvas_item_i2w_affine (item, i2w);
+ gnome_canvas_item_i2w_affine (item, i2w);
art_affine_point (&w1, &i1, i2w);
art_affine_point (&w2, &i2, i2w);
}
static void
-gtk_canvas_simpleline_reset_bounds (GtkCanvasItem *item)
+gnome_canvas_simpleline_reset_bounds (GnomeCanvasItem *item)
{
int Ix1, Ix2, Iy1, Iy2;
- gtk_canvas_simpleline_bounds_world (item, &Ix1, &Iy1, &Ix2, &Iy2);
- gtk_canvas_update_bbox (item, Ix1, Iy1, Ix2, Iy2);
+ gnome_canvas_simpleline_bounds_world (item, &Ix1, &Iy1, &Ix2, &Iy2);
+ gnome_canvas_update_bbox (item, Ix1, Iy1, Ix2, Iy2);
}
/*
*/
static void
-gtk_canvas_simpleline_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_simpleline_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasItem *item;
- GtkCanvasSimpleLine *simpleline;
+ GnomeCanvasItem *item;
+ GnomeCanvasSimpleLine *simpleline;
int redraw;
int calc_bounds;
- item = GTK_CANVAS_ITEM (object);
- simpleline = GTK_CANVAS_SIMPLELINE (object);
+ item = GNOME_CANVAS_ITEM (object);
+ simpleline = GNOME_CANVAS_SIMPLELINE (object);
redraw = FALSE;
calc_bounds = FALSE;
if (calc_bounds) {
- gtk_canvas_item_request_update (item);
+ gnome_canvas_item_request_update (item);
} else if (redraw) {
int Ix1, Ix2, Iy1, Iy2;
- gtk_canvas_simpleline_bounds_world (item, &Ix1, &Iy1, &Ix2, &Iy2);
- gtk_canvas_request_redraw (item->canvas, Ix1, Iy1, Ix2, Iy2);
+ gnome_canvas_simpleline_bounds_world (item, &Ix1, &Iy1, &Ix2, &Iy2);
+ gnome_canvas_request_redraw (item->canvas, Ix1, Iy1, Ix2, Iy2);
}
}
static void
-gtk_canvas_simpleline_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_simpleline_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasSimpleLine *simpleline;
+ GnomeCanvasSimpleLine *simpleline;
- simpleline = GTK_CANVAS_SIMPLELINE (object);
+ simpleline = GNOME_CANVAS_SIMPLELINE (object);
switch (arg_id) {
case ARG_X1:
}
static void
-gtk_canvas_simpleline_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
+gnome_canvas_simpleline_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
{
- GtkCanvasSimpleLine *simpleline;
+ GnomeCanvasSimpleLine *simpleline;
double x;
double y;
- simpleline = GTK_CANVAS_SIMPLELINE (item);
+ simpleline = GNOME_CANVAS_SIMPLELINE (item);
if (parent_class->update)
(* parent_class->update) (item, affine, clip_path, flags);
- gtk_canvas_simpleline_reset_bounds (item);
+ gnome_canvas_simpleline_reset_bounds (item);
x = simpleline->x1;
y = simpleline->y1;
- gtk_canvas_item_i2w (item, &x, &y);
- gtk_canvas_w2c (GTK_CANVAS(item->canvas), x, y, &simpleline->bbox_ulx, &simpleline->bbox_uly);
+ gnome_canvas_item_i2w (item, &x, &y);
+ gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &simpleline->bbox_ulx, &simpleline->bbox_uly);
x = simpleline->x2;
y = simpleline->y2;
- gtk_canvas_item_i2w (item, &x, &y);
- gtk_canvas_w2c (GTK_CANVAS(item->canvas), x, y, &simpleline->bbox_lrx, &simpleline->bbox_lry);
+ gnome_canvas_item_i2w (item, &x, &y);
+ gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &simpleline->bbox_lrx, &simpleline->bbox_lry);
}
static void
-gtk_canvas_simpleline_render (GtkCanvasItem *item,
- GtkCanvasBuf *buf)
+gnome_canvas_simpleline_render (GnomeCanvasItem *item,
+ GnomeCanvasBuf *buf)
{
- GtkCanvasSimpleLine *simpleline;
+ GnomeCanvasSimpleLine *simpleline;
int end, begin;
- simpleline = GTK_CANVAS_SIMPLELINE (item);
+ simpleline = GNOME_CANVAS_SIMPLELINE (item);
if (parent_class->render) {
(*parent_class->render) (item, buf);
}
if (buf->is_bg) {
- gtk_canvas_buf_ensure_buf (buf);
+ gnome_canvas_buf_ensure_buf (buf);
buf->is_bg = FALSE;
}
}
static void
-gtk_canvas_simpleline_draw (GtkCanvasItem *item,
+gnome_canvas_simpleline_draw (GnomeCanvasItem *item,
GdkDrawable *drawable,
int x, int y,
int width, int height)
{
- GtkCanvasSimpleLine *simpleline;
+ GnomeCanvasSimpleLine *simpleline;
- simpleline = GTK_CANVAS_SIMPLELINE (item);
+ simpleline = GNOME_CANVAS_SIMPLELINE (item);
if (parent_class->draw) {
(* parent_class->draw) (item, drawable, x, y, width, height);
}
static void
-gtk_canvas_simpleline_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+gnome_canvas_simpleline_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
{
- GtkCanvasSimpleLine *simpleline = GTK_CANVAS_SIMPLELINE (item);
+ GnomeCanvasSimpleLine *simpleline = GNOME_CANVAS_SIMPLELINE (item);
*x1 = simpleline->x1;
*y1 = simpleline->y1;
}
static double
-gtk_canvas_simpleline_point (GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item)
+gnome_canvas_simpleline_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
{
- GtkCanvasSimpleLine *simpleline;
+ GnomeCanvasSimpleLine *simpleline;
double x1, y1, x2, y2;
double dx, dy;
- simpleline = GTK_CANVAS_SIMPLELINE (item);
+ simpleline = GNOME_CANVAS_SIMPLELINE (item);
*actual_item = item;
/* Find the bounds for the rectangle plus its outline width */
- gtk_canvas_simpleline_bounds (item, &x1, &y1, &x2, &y2);
+ gnome_canvas_simpleline_bounds (item, &x1, &y1, &x2, &y2);
/* Is point inside rectangle */
-/* gtk-canvas-simpleline.h: GtkCanvas item for simple rects
+/* libgnomecanvas/gnome-canvas-simpleline.h: GnomeCanvas item for simple rects
*
* Copyright (C) 2001 Paul Davis <pbd@op.net>
*
*
*/
-#ifndef __GTK_CANVAS_SIMPLELINE_H__
-#define __GTK_CANVAS_SIMPLELINE_H__
+#ifndef __GNOME_CANVAS_SIMPLELINE_H__
+#define __GNOME_CANVAS_SIMPLELINE_H__
#include <stdint.h>
-#include <gtk-canvas/gtk-canvas-defs.h>
-#include "gtk-canvas/gtk-canvas.h"
+#include <libgnomecanvas/libgnomecanvas.h>
-BEGIN_GTK_CANVAS_DECLS
+BEGIN_GNOME_CANVAS_DECLS
/* Wave viewer item for canvas.
*/
-#define GTK_CANVAS_TYPE_CANVAS_SIMPLELINE (gtk_canvas_simpleline_get_type ())
-#define GTK_CANVAS_SIMPLELINE(obj) (GTK_CHECK_CAST ((obj), GTK_CANVAS_TYPE_CANVAS_SIMPLELINE, GtkCanvasSimpleLine))
-#define GTK_CANVAS_SIMPLELINE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_CANVAS_TYPE_CANVAS_SIMPLELINE, GtkCanvasSimpleLineClass))
-#define GTK_CANVAS_IS_CANVAS_SIMPLELINE(obj) (GTK_CHECK_TYPE ((obj), GTK_CANVAS_TYPE_CANVAS_SIMPLELINE))
-#define GTK_CANVAS_IS_CANVAS_SIMPLELINE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_CANVAS_TYPE_CANVAS_SIMPLELINE))
+#define GNOME_CANVAS_TYPE_CANVAS_SIMPLELINE (gnome_canvas_simpleline_get_type ())
+#define GNOME_CANVAS_SIMPLELINE(obj) (GTK_CHECK_CAST ((obj), GNOME_CANVAS_TYPE_CANVAS_SIMPLELINE, GnomeCanvasSimpleLine))
+#define GNOME_CANVAS_SIMPLELINE_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GNOME_CANVAS_TYPE_CANVAS_SIMPLELINE, GnomeCanvasSimpleLineClass))
+#define GNOME_CANVAS_IS_CANVAS_SIMPLELINE(obj) (GTK_CHECK_TYPE ((obj), GNOME_CANVAS_TYPE_CANVAS_SIMPLELINE))
+#define GNOME_CANVAS_IS_CANVAS_SIMPLELINE_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GNOME_CANVAS_TYPE_CANVAS_SIMPLELINE))
-typedef struct _GtkCanvasSimpleLine GtkCanvasSimpleLine;
-typedef struct _GtkCanvasSimpleLineClass GtkCanvasSimpleLineClass;
+typedef struct _GnomeCanvasSimpleLine GnomeCanvasSimpleLine;
+typedef struct _GnomeCanvasSimpleLineClass GnomeCanvasSimpleLineClass;
-struct _GtkCanvasSimpleLine
+struct _GnomeCanvasSimpleLine
{
- GtkCanvasItem item;
+ GnomeCanvasItem item;
double x1, y1, x2, y2;
uint32_t color;
gboolean horizontal;
guint32 bbox_lrx, bbox_lry;
};
-struct _GtkCanvasSimpleLineClass {
- GtkCanvasItemClass parent_class;
+struct _GnomeCanvasSimpleLineClass {
+ GnomeCanvasItemClass parent_class;
};
-GtkType gtk_canvas_simpleline_get_type (void);
+GtkType gnome_canvas_simpleline_get_type (void);
-END_GTK_CANVAS_DECLS
+END_GNOME_CANVAS_DECLS
-#endif /* __GTK_CANVAS_SIMPLELINE_H__ */
+#endif /* __GNOME_CANVAS_SIMPLELINE_H__ */
#include <stdio.h>
#include <math.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include "canvas-simplerect.h"
#include "rgb_macros.h"
};
-static void gtk_canvas_simplerect_class_init (GtkCanvasSimpleRectClass *class);
-static void gtk_canvas_simplerect_init (GtkCanvasSimpleRect *simplerect);
-static void gtk_canvas_simplerect_set_arg (GtkObject *object,
+static void gnome_canvas_simplerect_class_init (GnomeCanvasSimpleRectClass *class);
+static void gnome_canvas_simplerect_init (GnomeCanvasSimpleRect *simplerect);
+static void gnome_canvas_simplerect_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_canvas_simplerect_get_arg (GtkObject *object,
+static void gnome_canvas_simplerect_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_canvas_simplerect_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags);
-static void gtk_canvas_simplerect_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2);
-static double gtk_canvas_simplerect_point (GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item);
-static void gtk_canvas_simplerect_render (GtkCanvasItem *item, GtkCanvasBuf *buf);
-static void gtk_canvas_simplerect_draw (GtkCanvasItem *item, GdkDrawable *drawable, int x, int y, int w, int h);
+static void gnome_canvas_simplerect_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags);
+static void gnome_canvas_simplerect_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2);
+static double gnome_canvas_simplerect_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item);
+static void gnome_canvas_simplerect_render (GnomeCanvasItem *item, GnomeCanvasBuf *buf);
+static void gnome_canvas_simplerect_draw (GnomeCanvasItem *item, GdkDrawable *drawable, int x, int y, int w, int h);
-static GtkCanvasItemClass *parent_class;
+static GnomeCanvasItemClass *parent_class;
GtkType
-gtk_canvas_simplerect_get_type (void)
+gnome_canvas_simplerect_get_type (void)
{
static GtkType simplerect_type = 0;
if (!simplerect_type) {
GtkTypeInfo simplerect_info = {
- "GtkCanvasSimpleRect",
- sizeof (GtkCanvasSimpleRect),
- sizeof (GtkCanvasSimpleRectClass),
- (GtkClassInitFunc) gtk_canvas_simplerect_class_init,
- (GtkObjectInitFunc) gtk_canvas_simplerect_init,
+ "GnomeCanvasSimpleRect",
+ sizeof (GnomeCanvasSimpleRect),
+ sizeof (GnomeCanvasSimpleRectClass),
+ (GtkClassInitFunc) gnome_canvas_simplerect_class_init,
+ (GtkObjectInitFunc) gnome_canvas_simplerect_init,
NULL, /* reserved_1 */
NULL, /* reserved_2 */
(GtkClassInitFunc) NULL
};
- simplerect_type = gtk_type_unique (gtk_canvas_item_get_type (), &simplerect_info);
+ simplerect_type = gtk_type_unique (gnome_canvas_item_get_type (), &simplerect_info);
}
return simplerect_type;
}
static void
-gtk_canvas_simplerect_class_init (GtkCanvasSimpleRectClass *class)
+gnome_canvas_simplerect_class_init (GnomeCanvasSimpleRectClass *class)
{
GtkObjectClass *object_class;
- GtkCanvasItemClass *item_class;
+ GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass *) class;
- item_class = (GtkCanvasItemClass *) class;
-
- parent_class = gtk_type_class (gtk_canvas_item_get_type ());
-
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::x1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X1);
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::y1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y1);
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::x2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X2);
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::y2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y2);
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::fill", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_FILL);
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::draw", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW);
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::fill_color_rgba", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_FILL_COLOR_RGBA);
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::outline_color_rgba", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_OUTLINE_COLOR_RGBA);
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::outline_pixels", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_OUTLINE_PIXELS);
- gtk_object_add_arg_type ("GtkCanvasSimpleRect::outline_what", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_OUTLINE_WHAT);
-
- object_class->set_arg = gtk_canvas_simplerect_set_arg;
- object_class->get_arg = gtk_canvas_simplerect_get_arg;
-
- item_class->update = gtk_canvas_simplerect_update;
- item_class->bounds = gtk_canvas_simplerect_bounds;
- item_class->point = gtk_canvas_simplerect_point;
- item_class->render = gtk_canvas_simplerect_render;
- item_class->draw = gtk_canvas_simplerect_draw;
+ item_class = (GnomeCanvasItemClass *) class;
+
+ parent_class = gtk_type_class (gnome_canvas_item_get_type ());
+
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::x1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X1);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::y1", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y1);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::x2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X2);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::y2", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y2);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::fill", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_FILL);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::draw", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_DRAW);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::fill_color_rgba", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_FILL_COLOR_RGBA);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::outline_color_rgba", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_OUTLINE_COLOR_RGBA);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::outline_pixels", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_OUTLINE_PIXELS);
+ gtk_object_add_arg_type ("GnomeCanvasSimpleRect::outline_what", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_OUTLINE_WHAT);
+
+ object_class->set_arg = gnome_canvas_simplerect_set_arg;
+ object_class->get_arg = gnome_canvas_simplerect_get_arg;
+
+ item_class->update = gnome_canvas_simplerect_update;
+ item_class->bounds = gnome_canvas_simplerect_bounds;
+ item_class->point = gnome_canvas_simplerect_point;
+ item_class->render = gnome_canvas_simplerect_render;
+ item_class->draw = gnome_canvas_simplerect_draw;
}
static void
-gtk_canvas_simplerect_init (GtkCanvasSimpleRect *simplerect)
+gnome_canvas_simplerect_init (GnomeCanvasSimpleRect *simplerect)
{
simplerect->x1 = 0.0;
simplerect->y1 = 0.0;
simplerect->outline_pixels = 1;
simplerect->outline_what = 0xf;
- GTK_CANVAS_ITEM(simplerect)->object.flags |= GTK_CANVAS_ITEM_NO_AUTO_REDRAW;
+ GNOME_CANVAS_ITEM(simplerect)->object.flags |= GNOME_CANVAS_ITEM_NO_AUTO_REDRAW;
}
static void
-gtk_canvas_simplerect_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+gnome_canvas_simplerect_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
{
- GtkCanvasSimpleRect *simplerect = GTK_CANVAS_SIMPLERECT (item);
+ GnomeCanvasSimpleRect *simplerect = GNOME_CANVAS_SIMPLERECT (item);
*x1 = simplerect->x1;
*y1 = simplerect->y1;
}
static void
-gtk_canvas_simplerect_reset_bounds (GtkCanvasItem *item)
+gnome_canvas_simplerect_reset_bounds (GnomeCanvasItem *item)
{
- GtkCanvasSimpleRect* simplerect;
+ GnomeCanvasSimpleRect* simplerect;
double x1, x2, y1, y2;
double old_x1, old_x2, old_y1, old_y2;
double a, b;
old_x2 = item->x2;
old_y2 = item->y2;
- gtk_canvas_simplerect_bounds (item, &x1, &y1, &x2, &y2);
- gtk_canvas_item_i2w (item, &x1, &y1);
- gtk_canvas_item_i2w (item, &x2, &y2);
+ gnome_canvas_simplerect_bounds (item, &x1, &y1, &x2, &y2);
+ gnome_canvas_item_i2w (item, &x1, &y1);
+ gnome_canvas_item_i2w (item, &x2, &y2);
item->x1 = x1;
item->y1 = y1;
/* now compute bounding box in canvas units */
- simplerect = GTK_CANVAS_SIMPLERECT (item);
+ simplerect = GNOME_CANVAS_SIMPLERECT (item);
- gtk_canvas_w2c (GTK_CANVAS(item->canvas), x1, y1, &simplerect->bbox_ulx, &simplerect->bbox_uly);
- gtk_canvas_w2c (GTK_CANVAS(item->canvas), x2, y2, &simplerect->bbox_lrx, &simplerect->bbox_lry);
+ gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x1, y1, &simplerect->bbox_ulx, &simplerect->bbox_uly);
+ gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x2, y2, &simplerect->bbox_lrx, &simplerect->bbox_lry);
/* now queue redraws for changed areas */
a = MIN(item->x1, old_x1);
b = MAX(item->x1, old_x1);
- gtk_canvas_request_redraw (item->canvas, a - 1, item->y1, b + 1, item->y2);
+ gnome_canvas_request_redraw (item->canvas, a - 1, item->y1, b + 1, item->y2);
}
if (item->x2 != old_x2) {
a = MIN(item->x2, old_x2);
b = MAX(item->x2, old_x2);
- gtk_canvas_request_redraw (item->canvas, a - 1, item->y1, b + 1, item->y2);
+ gnome_canvas_request_redraw (item->canvas, a - 1, item->y1, b + 1, item->y2);
}
if (item->y1 != old_y1) {
a = MIN(item->y1, old_y1);
b = MAX(item->y1, old_y1);
- gtk_canvas_request_redraw (item->canvas, item->x1, a - 1, item->x2, b + 1);
+ gnome_canvas_request_redraw (item->canvas, item->x1, a - 1, item->x2, b + 1);
}
if (item->y2 != old_y2) {
a = MIN(item->y2, old_y2);
b = MAX(item->y2, old_y2);
- gtk_canvas_request_redraw (item->canvas, item->x1, a - 1, item->x2, b + 1);
+ gnome_canvas_request_redraw (item->canvas, item->x1, a - 1, item->x2, b + 1);
}
}
*/
static void
-gtk_canvas_simplerect_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_simplerect_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasItem *item;
- GtkCanvasSimpleRect *simplerect;
+ GnomeCanvasItem *item;
+ GnomeCanvasSimpleRect *simplerect;
int update;
int bounds_changed;
- item = GTK_CANVAS_ITEM (object);
- simplerect = GTK_CANVAS_SIMPLERECT (object);
+ item = GNOME_CANVAS_ITEM (object);
+ simplerect = GNOME_CANVAS_SIMPLERECT (object);
update = FALSE;
bounds_changed = FALSE;
simplerect->full_draw_on_update = update;
if (update || bounds_changed) {
- gtk_canvas_item_request_update (item);
+ gnome_canvas_item_request_update (item);
}
}
static void
-gtk_canvas_simplerect_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_simplerect_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasSimpleRect *simplerect;
+ GnomeCanvasSimpleRect *simplerect;
- simplerect = GTK_CANVAS_SIMPLERECT (object);
+ simplerect = GNOME_CANVAS_SIMPLERECT (object);
switch (arg_id) {
case ARG_X1:
}
static void
-gtk_canvas_simplerect_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
+gnome_canvas_simplerect_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
{
- GtkCanvasSimpleRect *simplerect;
+ GnomeCanvasSimpleRect *simplerect;
unsigned char foo;
- simplerect = GTK_CANVAS_SIMPLERECT (item);
+ simplerect = GNOME_CANVAS_SIMPLERECT (item);
if (parent_class->update)
(* parent_class->update) (item, affine, clip_path, flags);
- gtk_canvas_simplerect_reset_bounds (item);
+ gnome_canvas_simplerect_reset_bounds (item);
if (simplerect->full_draw_on_update) {
- gtk_canvas_request_redraw (item->canvas,
+ gnome_canvas_request_redraw (item->canvas,
simplerect->bbox_ulx,
simplerect->bbox_uly,
simplerect->bbox_lrx+1,
#ifdef SIMPLERECT_FAST_RENDERER
static void
-gtk_canvas_simplerect_render (GtkCanvasItem *item,
- GtkCanvasBuf *buf)
+gnome_canvas_simplerect_render (GnomeCanvasItem *item,
+ GnomeCanvasBuf *buf)
{
- GtkCanvasSimpleRect *simplerect;
+ GnomeCanvasSimpleRect *simplerect;
int end, begin;
int ey, sy;
unsigned int i;
ArtIRect intersection;
ArtIRect self;
- simplerect = GTK_CANVAS_SIMPLERECT (item);
+ simplerect = GNOME_CANVAS_SIMPLERECT (item);
if (parent_class->render) {
(*parent_class->render) (item, buf);
// randb = random() % 255;
// PAINT_BOX(buf, randr, randg, randb, 255, buf->rect.x0, buf->rect.y0, buf->rect.x1, buf->rect.y1);
- gtk_canvas_buf_ensure_buf (buf);
+ gnome_canvas_buf_ensure_buf (buf);
buf->is_bg = FALSE;
}
#else /* SIMPLERECT_FAST_RENDERER */
static void
-gtk_canvas_simplerect_render (GtkCanvasItem *item,
- GtkCanvasBuf *buf)
+gnome_canvas_simplerect_render (GnomeCanvasItem *item,
+ GnomeCanvasBuf *buf)
{
- GtkCanvasSimpleRect *simplerect;
+ GnomeCanvasSimpleRect *simplerect;
int end, begin;
int ey, sy;
unsigned int i;
- simplerect = GTK_CANVAS_SIMPLERECT (item);
+ simplerect = GNOME_CANVAS_SIMPLERECT (item);
if (parent_class->render) {
(*parent_class->render) (item, buf);
// randb = random() % 255;
// PAINT_BOX(buf, randr, randg, randb, 255, buf->rect.x0, buf->rect.y0, buf->rect.x1, buf->rect.y1);
- gtk_canvas_buf_ensure_buf (buf);
+ gnome_canvas_buf_ensure_buf (buf);
buf->is_bg = FALSE;
}
#endif /* SIMPLERECT_FAST_RENDERER */
static void
-gtk_canvas_simplerect_draw (GtkCanvasItem *item,
+gnome_canvas_simplerect_draw (GnomeCanvasItem *item,
GdkDrawable *drawable,
int x, int y,
int width, int height)
}
static double
-gtk_canvas_simplerect_point (GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item)
+gnome_canvas_simplerect_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
{
- GtkCanvasSimpleRect *simplerect;
+ GnomeCanvasSimpleRect *simplerect;
double x1, y1, x2, y2;
double dx, dy;
- simplerect = GTK_CANVAS_SIMPLERECT (item);
+ simplerect = GNOME_CANVAS_SIMPLERECT (item);
*actual_item = item;
/* Find the bounds for the rectangle plus its outline width */
- gtk_canvas_simplerect_bounds (item, &x1, &y1, &x2, &y2);
+ gnome_canvas_simplerect_bounds (item, &x1, &y1, &x2, &y2);
/* Is point inside rectangle */
-/* gtk-canvas-simplerect.h: GtkCanvas item for simple rects
+/* libgnomecanvas/gnome-canvas-simplerect.h: GnomeCanvas item for simple rects
*
* Copyright (C) 2001 Paul Davis <pbd@op.net>
*
*
*/
-#ifndef __GTK_CANVAS_SIMPLERECT_H__
-#define __GTK_CANVAS_SIMPLERECT_H__
+#ifndef __GNOME_CANVAS_SIMPLERECT_H__
+#define __GNOME_CANVAS_SIMPLERECT_H__
#include <stdint.h>
-#include <gtk-canvas/gtk-canvas-defs.h>
-#include "gtk-canvas/gtk-canvas.h"
+#include <libgnomecanvas/libgnomecanvas.h>
-BEGIN_GTK_CANVAS_DECLS
+BEGIN_GNOME_CANVAS_DECLS
/* Wave viewer item for canvas.
*/
-#define GTK_CANVAS_TYPE_CANVAS_SIMPLERECT (gtk_canvas_simplerect_get_type ())
-#define GTK_CANVAS_SIMPLERECT(obj) (GTK_CHECK_CAST ((obj), GTK_CANVAS_TYPE_CANVAS_SIMPLERECT, GtkCanvasSimpleRect))
-#define GTK_CANVAS_SIMPLERECT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_CANVAS_TYPE_CANVAS_SIMPLERECT, GtkCanvasSimpleRectClass))
-#define GTK_CANVAS_IS_CANVAS_SIMPLERECT(obj) (GTK_CHECK_TYPE ((obj), GTK_CANVAS_TYPE_CANVAS_SIMPLERECT))
-#define GTK_CANVAS_IS_CANVAS_SIMPLERECT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_CANVAS_TYPE_CANVAS_SIMPLERECT))
+#define GNOME_CANVAS_TYPE_CANVAS_SIMPLERECT (gnome_canvas_simplerect_get_type ())
+#define GNOME_CANVAS_SIMPLERECT(obj) (GTK_CHECK_CAST ((obj), GNOME_CANVAS_TYPE_CANVAS_SIMPLERECT, GnomeCanvasSimpleRect))
+#define GNOME_CANVAS_SIMPLERECT_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GNOME_CANVAS_TYPE_CANVAS_SIMPLERECT, GnomeCanvasSimpleRectClass))
+#define GNOME_CANVAS_IS_CANVAS_SIMPLERECT(obj) (GTK_CHECK_TYPE ((obj), GNOME_CANVAS_TYPE_CANVAS_SIMPLERECT))
+#define GNOME_CANVAS_IS_CANVAS_SIMPLERECT_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GNOME_CANVAS_TYPE_CANVAS_SIMPLERECT))
-typedef struct _GtkCanvasSimpleRect GtkCanvasSimpleRect;
-typedef struct _GtkCanvasSimpleRectClass GtkCanvasSimpleRectClass;
+typedef struct _GnomeCanvasSimpleRect GnomeCanvasSimpleRect;
+typedef struct _GnomeCanvasSimpleRectClass GnomeCanvasSimpleRectClass;
-struct _GtkCanvasSimpleRect
+struct _GnomeCanvasSimpleRect
{
- GtkCanvasItem item;
+ GnomeCanvasItem item;
double x1, y1, x2, y2;
gboolean fill;
gboolean draw;
guint32 bbox_lrx, bbox_lry;
};
-struct _GtkCanvasSimpleRectClass {
- GtkCanvasItemClass parent_class;
+struct _GnomeCanvasSimpleRectClass {
+ GnomeCanvasItemClass parent_class;
};
-GtkType gtk_canvas_simplerect_get_type (void);
+GtkType gnome_canvas_simplerect_get_type (void);
-END_GTK_CANVAS_DECLS
+END_GNOME_CANVAS_DECLS
-#endif /* __GTK_CANVAS_SIMPLERECT_H__ */
+#endif /* __GNOME_CANVAS_SIMPLERECT_H__ */
#include <stdio.h>
#include <math.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <string.h>
#include <limits.h>
ARG_REGION_START
};
-static void gtk_canvas_waveview_class_init (GtkCanvasWaveViewClass *class);
-static void gtk_canvas_waveview_init (GtkCanvasWaveView *waveview);
-static void gtk_canvas_waveview_set_arg (GtkObject *object,
+static void gnome_canvas_waveview_class_init (GnomeCanvasWaveViewClass *class);
+static void gnome_canvas_waveview_init (GnomeCanvasWaveView *waveview);
+static void gnome_canvas_waveview_set_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_canvas_waveview_get_arg (GtkObject *object,
+static void gnome_canvas_waveview_get_arg (GtkObject *object,
GtkArg *arg,
guint arg_id);
-static void gtk_canvas_waveview_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags);
-static void gtk_canvas_waveview_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2);
-static double gtk_canvas_waveview_point (GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item);
+static void gnome_canvas_waveview_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags);
+static void gnome_canvas_waveview_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2);
+static double gnome_canvas_waveview_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item);
-static void gtk_canvas_waveview_render (GtkCanvasItem *item, GtkCanvasBuf *buf);
-static void gtk_canvas_waveview_draw (GtkCanvasItem *item, GdkDrawable *drawable, int x, int y, int w, int h);
+static void gnome_canvas_waveview_render (GnomeCanvasItem *item, GnomeCanvasBuf *buf);
+static void gnome_canvas_waveview_draw (GnomeCanvasItem *item, GdkDrawable *drawable, int x, int y, int w, int h);
-static void gtk_canvas_waveview_set_data_src (GtkCanvasWaveView *, void *);
-static void gtk_canvas_waveview_set_channel (GtkCanvasWaveView *, guint32);
+static void gnome_canvas_waveview_set_data_src (GnomeCanvasWaveView *, void *);
+static void gnome_canvas_waveview_set_channel (GnomeCanvasWaveView *, guint32);
-static gint32 gtk_canvas_waveview_ensure_cache (GtkCanvasWaveView *waveview, gulong start_sample, gulong end_sample);
+static gint32 gnome_canvas_waveview_ensure_cache (GnomeCanvasWaveView *waveview, gulong start_sample, gulong end_sample);
-static GtkCanvasItemClass *parent_class;
+static GnomeCanvasItemClass *parent_class;
GtkType
-gtk_canvas_waveview_get_type (void)
+gnome_canvas_waveview_get_type (void)
{
static GtkType waveview_type = 0;
if (!waveview_type) {
GtkTypeInfo waveview_info = {
- "GtkCanvasWaveView",
- sizeof (GtkCanvasWaveView),
- sizeof (GtkCanvasWaveViewClass),
- (GtkClassInitFunc) gtk_canvas_waveview_class_init,
- (GtkObjectInitFunc) gtk_canvas_waveview_init,
+ "GnomeCanvasWaveView",
+ sizeof (GnomeCanvasWaveView),
+ sizeof (GnomeCanvasWaveViewClass),
+ (GtkClassInitFunc) gnome_canvas_waveview_class_init,
+ (GtkObjectInitFunc) gnome_canvas_waveview_init,
NULL, /* reserved_1 */
NULL, /* reserved_2 */
(GtkClassInitFunc) NULL
};
- waveview_type = gtk_type_unique (gtk_canvas_item_get_type (), &waveview_info);
+ waveview_type = gtk_type_unique (gnome_canvas_item_get_type (), &waveview_info);
}
return waveview_type;
}
static void
-gtk_canvas_waveview_class_init (GtkCanvasWaveViewClass *class)
+gnome_canvas_waveview_class_init (GnomeCanvasWaveViewClass *class)
{
GtkObjectClass *object_class;
- GtkCanvasItemClass *item_class;
+ GnomeCanvasItemClass *item_class;
object_class = (GtkObjectClass *) class;
- item_class = (GtkCanvasItemClass *) class;
-
- parent_class = gtk_type_class (gtk_canvas_item_get_type ());
-
- gtk_object_add_arg_type ("GtkCanvasWaveView::data_src", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_DATA_SRC);
- gtk_object_add_arg_type ("GtkCanvasWaveView::channel", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_CHANNEL);
- gtk_object_add_arg_type ("GtkCanvasWaveView::length_function", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_LENGTH_FUNCTION);
- gtk_object_add_arg_type ("GtkCanvasWaveView::sourcefile_length_function", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_SOURCEFILE_LENGTH_FUNCTION);
- gtk_object_add_arg_type ("GtkCanvasWaveView::peak_function", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_PEAK_FUNCTION);
- gtk_object_add_arg_type ("GtkCanvasWaveView::gain_function", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_GAIN_FUNCTION);
- gtk_object_add_arg_type ("GtkCanvasWaveView::gain_src", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_GAIN_SRC);
- gtk_object_add_arg_type ("GtkCanvasWaveView::cache", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_CACHE);
- gtk_object_add_arg_type ("GtkCanvasWaveView::cache_updater", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_CACHE_UPDATER);
- gtk_object_add_arg_type ("GtkCanvasWaveView::samples_per_unit", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_SAMPLES_PER_PIXEL);
- gtk_object_add_arg_type ("GtkCanvasWaveView::amplitude_above_axis", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_AMPLITUDE_ABOVE_AXIS);
- gtk_object_add_arg_type ("GtkCanvasWaveView::x", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X);
- gtk_object_add_arg_type ("GtkCanvasWaveView::y", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y);
- gtk_object_add_arg_type ("GtkCanvasWaveView::height", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_HEIGHT);
- gtk_object_add_arg_type ("GtkCanvasWaveView::wave_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_WAVE_COLOR);
- gtk_object_add_arg_type ("GtkCanvasWaveView::rectified", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_RECTIFIED);
- gtk_object_add_arg_type ("GtkCanvasWaveView::region_start", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_REGION_START);
-
- object_class->set_arg = gtk_canvas_waveview_set_arg;
- object_class->get_arg = gtk_canvas_waveview_get_arg;
-
- item_class->update = gtk_canvas_waveview_update;
- item_class->bounds = gtk_canvas_waveview_bounds;
- item_class->point = gtk_canvas_waveview_point;
- item_class->render = gtk_canvas_waveview_render;
- item_class->draw = gtk_canvas_waveview_draw;
+ item_class = (GnomeCanvasItemClass *) class;
+
+ parent_class = gtk_type_class (gnome_canvas_item_get_type ());
+
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::data_src", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_DATA_SRC);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::channel", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_CHANNEL);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::length_function", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_LENGTH_FUNCTION);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::sourcefile_length_function", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_SOURCEFILE_LENGTH_FUNCTION);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::peak_function", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_PEAK_FUNCTION);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::gain_function", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_GAIN_FUNCTION);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::gain_src", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_GAIN_SRC);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::cache", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_CACHE);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::cache_updater", GTK_TYPE_POINTER, GTK_ARG_READWRITE, ARG_CACHE_UPDATER);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::samples_per_unit", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_SAMPLES_PER_PIXEL);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::amplitude_above_axis", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_AMPLITUDE_ABOVE_AXIS);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::x", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_X);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::y", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_Y);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::height", GTK_TYPE_DOUBLE, GTK_ARG_READWRITE, ARG_HEIGHT);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::wave_color", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_WAVE_COLOR);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::rectified", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_RECTIFIED);
+ gtk_object_add_arg_type ("GnomeCanvasWaveView::region_start", GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_REGION_START);
+
+ object_class->set_arg = gnome_canvas_waveview_set_arg;
+ object_class->get_arg = gnome_canvas_waveview_get_arg;
+
+ item_class->update = gnome_canvas_waveview_update;
+ item_class->bounds = gnome_canvas_waveview_bounds;
+ item_class->point = gnome_canvas_waveview_point;
+ item_class->render = gnome_canvas_waveview_render;
+ item_class->draw = gnome_canvas_waveview_draw;
}
-GtkCanvasWaveViewCache*
-gtk_canvas_waveview_cache_new ()
+GnomeCanvasWaveViewCache*
+gnome_canvas_waveview_cache_new ()
{
- GtkCanvasWaveViewCache *c;
+ GnomeCanvasWaveViewCache *c;
- c = g_malloc (sizeof (GtkCanvasWaveViewCache));
+ c = g_malloc (sizeof (GnomeCanvasWaveViewCache));
c->allocated = 2048;
- c->data = g_malloc (sizeof (GtkCanvasWaveViewCacheEntry) * c->allocated);
+ c->data = g_malloc (sizeof (GnomeCanvasWaveViewCacheEntry) * c->allocated);
c->data_size = 0;
c->start = 0;
c->end = 0;
}
void
-gtk_canvas_waveview_cache_destroy (GtkCanvasWaveViewCache* cache)
+gnome_canvas_waveview_cache_destroy (GnomeCanvasWaveViewCache* cache)
{
g_free (cache->data);
g_free (cache);
}
static void
-gtk_canvas_waveview_init (GtkCanvasWaveView *waveview)
+gnome_canvas_waveview_init (GnomeCanvasWaveView *waveview)
{
waveview->x = 0.0;
waveview->y = 0.0;
waveview->wave_color = RGBA_TO_UINT(44,35,126,255);
- GTK_CANVAS_ITEM(waveview)->object.flags |= GTK_CANVAS_ITEM_NO_AUTO_REDRAW;
+ GNOME_CANVAS_ITEM(waveview)->object.flags |= GNOME_CANVAS_ITEM_NO_AUTO_REDRAW;
}
#define DEBUG_CACHE 0
static gint32
-gtk_canvas_waveview_ensure_cache (GtkCanvasWaveView *waveview, gulong start_sample, gulong end_sample)
+gnome_canvas_waveview_ensure_cache (GnomeCanvasWaveView *waveview, gulong start_sample, gulong end_sample)
{
gulong required_cache_entries;
gulong rf1, rf2,rf3, required_frames;
gulong present_frames;
gulong present_entries;
gulong copied;
- GtkCanvasWaveViewCache *cache;
+ GnomeCanvasWaveViewCache *cache;
float* gain;
cache = waveview->cache;
#endif
if (required_cache_entries > cache->allocated) {
- cache->data = g_realloc (cache->data, sizeof (GtkCanvasWaveViewCacheEntry) * required_cache_entries);
+ cache->data = g_realloc (cache->data, sizeof (GnomeCanvasWaveViewCacheEntry) * required_cache_entries);
cache->allocated = required_cache_entries;
// cache->start = 0;
// cache->end = 0;
memmove (&cache->data[0],
&cache->data[cache->data_size - present_entries],
- present_entries * sizeof (GtkCanvasWaveViewCacheEntry));
+ present_entries * sizeof (GnomeCanvasWaveViewCacheEntry));
#if DEBUG_CACHE
fprintf (stderr, "satisfied %lu of %lu frames, offset = %lu, will start at %lu (ptr = 0x%x)\n",
memmove (&cache->data[cache->data_size - present_entries],
&cache->data[0],
- present_entries * sizeof (GtkCanvasWaveViewCacheEntry));
+ present_entries * sizeof (GnomeCanvasWaveViewCacheEntry));
#if DEBUG_CACHE
fprintf (stderr, "existing material at start of current cache, move to start of end cache\n");
#if DEBUG_CACHE
fprintf (stderr, "zero fill cache for %lu at %lu\n", cache->allocated - npeaks, npeaks);
#endif
- memset (&cache->data[npeaks], 0, sizeof (GtkCanvasWaveViewCacheEntry) * (cache->allocated - npeaks));
+ memset (&cache->data[npeaks], 0, sizeof (GnomeCanvasWaveViewCacheEntry) * (cache->allocated - npeaks));
cache->data_size = npeaks;
} else {
cache->data_size = cache->allocated;
}
void
-gtk_canvas_waveview_set_data_src (GtkCanvasWaveView *waveview, void *data_src)
+gnome_canvas_waveview_set_data_src (GnomeCanvasWaveView *waveview, void *data_src)
{
if (waveview->cache_updater) {
}
void
-gtk_canvas_waveview_set_channel (GtkCanvasWaveView *waveview, guint32 chan)
+gnome_canvas_waveview_set_channel (GnomeCanvasWaveView *waveview, guint32 chan)
{
if (waveview->channel == chan) {
return;
}
static void
-gtk_canvas_waveview_reset_bounds (GtkCanvasItem *item)
+gnome_canvas_waveview_reset_bounds (GnomeCanvasItem *item)
{
double x1, x2, y1, y2;
int Ix1, Ix2, Iy1, Iy2;
double i2w[6];
- gtk_canvas_waveview_bounds (item, &x1, &y1, &x2, &y2);
+ gnome_canvas_waveview_bounds (item, &x1, &y1, &x2, &y2);
i1.x = x1;
i1.y = y1;
i2.x = x2;
i2.y = y2;
- gtk_canvas_item_i2w_affine (item, i2w);
+ gnome_canvas_item_i2w_affine (item, i2w);
art_affine_point (&w1, &i1, i2w);
art_affine_point (&w2, &i2, i2w);
Iy1 = (int) rint(w1.y);
Iy2 = (int) rint(w2.y);
- gtk_canvas_update_bbox (item, Ix1, Iy1, Ix2, Iy2);
+ gnome_canvas_update_bbox (item, Ix1, Iy1, Ix2, Iy2);
}
/*
*/
static void
-gtk_canvas_waveview_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_waveview_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasItem *item;
- GtkCanvasWaveView *waveview;
+ GnomeCanvasItem *item;
+ GnomeCanvasWaveView *waveview;
int redraw;
int calc_bounds;
- item = GTK_CANVAS_ITEM (object);
- waveview = GTK_CANVAS_WAVEVIEW (object);
+ item = GNOME_CANVAS_ITEM (object);
+ waveview = GNOME_CANVAS_WAVEVIEW (object);
redraw = FALSE;
calc_bounds = FALSE;
switch (arg_id) {
case ARG_DATA_SRC:
- gtk_canvas_waveview_set_data_src (waveview, GTK_VALUE_POINTER(*arg));
+ gnome_canvas_waveview_set_data_src (waveview, GTK_VALUE_POINTER(*arg));
redraw = TRUE;
break;
case ARG_CHANNEL:
- gtk_canvas_waveview_set_channel (waveview, GTK_VALUE_UINT(*arg));
+ gnome_canvas_waveview_set_channel (waveview, GTK_VALUE_UINT(*arg));
redraw = TRUE;
break;
}
if (calc_bounds) {
- gtk_canvas_waveview_reset_bounds (item);
+ gnome_canvas_waveview_reset_bounds (item);
}
if (redraw) {
- gtk_canvas_item_request_update (item);
+ gnome_canvas_item_request_update (item);
}
}
static void
-gtk_canvas_waveview_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
+gnome_canvas_waveview_get_arg (GtkObject *object, GtkArg *arg, guint arg_id)
{
- GtkCanvasWaveView *waveview;
+ GnomeCanvasWaveView *waveview;
- waveview = GTK_CANVAS_WAVEVIEW (object);
+ waveview = GNOME_CANVAS_WAVEVIEW (object);
switch (arg_id) {
case ARG_DATA_SRC:
}
static void
-gtk_canvas_waveview_update (GtkCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
+gnome_canvas_waveview_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
{
- GtkCanvasWaveView *waveview;
+ GnomeCanvasWaveView *waveview;
double x, y;
- waveview = GTK_CANVAS_WAVEVIEW (item);
+ waveview = GNOME_CANVAS_WAVEVIEW (item);
// check_cache (waveview, "start of update");
if (parent_class->update)
(* parent_class->update) (item, affine, clip_path, flags);
- gtk_canvas_waveview_reset_bounds (item);
+ gnome_canvas_waveview_reset_bounds (item);
/* get the canvas coordinates of the view. Do NOT use affines
for this, because they do not round to the integer units used
x = waveview->x;
y = waveview->y;
- gtk_canvas_item_i2w (item, &x, &y);
- gtk_canvas_w2c (GTK_CANVAS(item->canvas), x, y, &waveview->bbox_ulx, &waveview->bbox_uly);
+ gnome_canvas_item_i2w (item, &x, &y);
+ gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &waveview->bbox_ulx, &waveview->bbox_uly);
waveview->samples = waveview->length_function (waveview->data_src);
x = waveview->x + (waveview->samples / waveview->samples_per_unit);
y = waveview->y + waveview->height;
- gtk_canvas_item_i2w (item, &x, &y);
- gtk_canvas_w2c (GTK_CANVAS(item->canvas), x, y, &waveview->bbox_lrx, &waveview->bbox_lry);
+ gnome_canvas_item_i2w (item, &x, &y);
+ gnome_canvas_w2c (GNOME_CANVAS(item->canvas), x, y, &waveview->bbox_lrx, &waveview->bbox_lry);
/* cache the half-height and the end point in canvas units */
}
static void
-gtk_canvas_waveview_render (GtkCanvasItem *item,
- GtkCanvasBuf *buf)
+gnome_canvas_waveview_render (GnomeCanvasItem *item,
+ GnomeCanvasBuf *buf)
{
- GtkCanvasWaveView *waveview;
+ GnomeCanvasWaveView *waveview;
gulong s1, s2;
int clip_length = 0;
int pymin, pymax;
double half_height;
int x, end, begin;
- waveview = GTK_CANVAS_WAVEVIEW (item);
+ waveview = GNOME_CANVAS_WAVEVIEW (item);
// check_cache (waveview, "start of render");
}
if (buf->is_bg) {
- gtk_canvas_buf_ensure_buf (buf);
+ gnome_canvas_buf_ensure_buf (buf);
buf->is_bg = FALSE;
}
waveview->reload_cache_in_render = FALSE;
}
- cache_index = gtk_canvas_waveview_ensure_cache (waveview, s1, s2);
+ cache_index = gnome_canvas_waveview_ensure_cache (waveview, s1, s2);
// check_cache (waveview, "post-ensure");
}
static void
-gtk_canvas_waveview_draw (GtkCanvasItem *item,
+gnome_canvas_waveview_draw (GnomeCanvasItem *item,
GdkDrawable *drawable,
int x, int y,
int width, int height)
{
- GtkCanvasWaveView *waveview;
+ GnomeCanvasWaveView *waveview;
- waveview = GTK_CANVAS_WAVEVIEW (item);
+ waveview = GNOME_CANVAS_WAVEVIEW (item);
if (parent_class->draw) {
(* parent_class->draw) (item, drawable, x, y, width, height);
}
static void
-gtk_canvas_waveview_bounds (GtkCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
+gnome_canvas_waveview_bounds (GnomeCanvasItem *item, double *x1, double *y1, double *x2, double *y2)
{
- GtkCanvasWaveView *waveview = GTK_CANVAS_WAVEVIEW (item);
+ GnomeCanvasWaveView *waveview = GNOME_CANVAS_WAVEVIEW (item);
*x1 = waveview->x;
*y1 = waveview->y;
#if 0
x = 0; y = 0;
- gtk_canvas_item_i2w (item, &x, &y);
- gtk_canvas_w2c_d (GTK_CANVAS(item->canvas), x, y, &a, &b);
+ gnome_canvas_item_i2w (item, &x, &y);
+ gnome_canvas_w2c_d (GNOME_CANVAS(item->canvas), x, y, &a, &b);
x = *x2;
y = *y2;
- gtk_canvas_item_i2w (item, &x, &y);
- gtk_canvas_w2c_d (GTK_CANVAS(item->canvas), x, y, &c, &d);
+ gnome_canvas_item_i2w (item, &x, &y);
+ gnome_canvas_w2c_d (GNOME_CANVAS(item->canvas), x, y, &c, &d);
printf ("item bounds now (%g,%g),(%g,%g)\n", a, b, c, d);
#endif
}
static double
-gtk_canvas_waveview_point (GtkCanvasItem *item, double x, double y, int cx, int cy, GtkCanvasItem **actual_item)
+gnome_canvas_waveview_point (GnomeCanvasItem *item, double x, double y, int cx, int cy, GnomeCanvasItem **actual_item)
{
/* XXX for now, point is never inside the wave
- GtkCanvasWaveView *waveview;
+ GnomeCanvasWaveView *waveview;
double x1, y1, x2, y2;
double dx, dy;
*/
return DBL_MAX;
#if 0
- waveview = GTK_CANVAS_WAVEVIEW (item);
+ waveview = GNOME_CANVAS_WAVEVIEW (item);
*actual_item = item;
/* Find the bounds for the rectangle plus its outline width */
- gtk_canvas_waveview_bounds (item, &x1, &y1, &x2, &y2);
+ gnome_canvas_waveview_bounds (item, &x1, &y1, &x2, &y2);
/* Is point inside rectangle */
-/* gtk-canvas-waveview.h: GtkCanvas item for displaying wave data
+/* libgnomecanvas/gnome-canvas-waveview.h: GnomeCanvas item for displaying wave data
*
* Copyright (C) 2001 Paul Davis <pbd@op.net>
*
*
*/
-#ifndef __GTK_CANVAS_WAVEVIEW_H__
-#define __GTK_CANVAS_WAVEVIEW_H__
+#ifndef __GNOME_CANVAS_WAVEVIEW_H__
+#define __GNOME_CANVAS_WAVEVIEW_H__
#include <stdint.h>
-#include <gtk-canvas/gtk-canvas-defs.h>
-#include "gtk-canvas/gtk-canvas.h"
+#include <libgnomecanvas/libgnomecanvas.h>
-BEGIN_GTK_CANVAS_DECLS
+BEGIN_GNOME_CANVAS_DECLS
/* Wave viewer item for canvas.
*/
-#define GTK_CANVAS_TYPE_CANVAS_WAVEVIEW (gtk_canvas_waveview_get_type ())
-#define GTK_CANVAS_WAVEVIEW(obj) (GTK_CHECK_CAST ((obj), GTK_CANVAS_TYPE_CANVAS_WAVEVIEW, GtkCanvasWaveView))
-#define GTK_CANVAS_WAVEVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_CANVAS_TYPE_CANVAS_WAVEVIEW, GtkCanvasWaveViewClass))
-#define GTK_CANVAS_IS_CANVAS_WAVEVIEW(obj) (GTK_CHECK_TYPE ((obj), GTK_CANVAS_TYPE_CANVAS_WAVEVIEW))
-#define GTK_CANVAS_IS_CANVAS_WAVEVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_CANVAS_TYPE_CANVAS_WAVEVIEW))
+#define GNOME_CANVAS_TYPE_CANVAS_WAVEVIEW (gnome_canvas_waveview_get_type ())
+#define GNOME_CANVAS_WAVEVIEW(obj) (GTK_CHECK_CAST ((obj), GNOME_CANVAS_TYPE_CANVAS_WAVEVIEW, GnomeCanvasWaveView))
+#define GNOME_CANVAS_WAVEVIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GNOME_CANVAS_TYPE_CANVAS_WAVEVIEW, GnomeCanvasWaveViewClass))
+#define GNOME_CANVAS_IS_CANVAS_WAVEVIEW(obj) (GTK_CHECK_TYPE ((obj), GNOME_CANVAS_TYPE_CANVAS_WAVEVIEW))
+#define GNOME_CANVAS_IS_CANVAS_WAVEVIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GNOME_CANVAS_TYPE_CANVAS_WAVEVIEW))
-typedef struct _GtkCanvasWaveView GtkCanvasWaveView;
-typedef struct _GtkCanvasWaveViewClass GtkCanvasWaveViewClass;
-typedef struct _GtkCanvasWaveViewChannelInfo GtkCanvasWaveViewChannelInfo;
-typedef struct _GtkCanvasWaveViewCacheEntry GtkCanvasWaveViewCacheEntry;
-typedef struct _GtkCanvasWaveViewCache GtkCanvasWaveViewCache;
+typedef struct _GnomeCanvasWaveView GnomeCanvasWaveView;
+typedef struct _GnomeCanvasWaveViewClass GnomeCanvasWaveViewClass;
+typedef struct _GnomeCanvasWaveViewChannelInfo GnomeCanvasWaveViewChannelInfo;
+typedef struct _GnomeCanvasWaveViewCacheEntry GnomeCanvasWaveViewCacheEntry;
+typedef struct _GnomeCanvasWaveViewCache GnomeCanvasWaveViewCache;
/* XXX this needs to be synced with ardour/source.h PeakData */
-struct _GtkCanvasWaveViewCacheEntry
+struct _GnomeCanvasWaveViewCacheEntry
{
float min;
float max;
};
-struct _GtkCanvasWaveViewCache
+struct _GnomeCanvasWaveViewCache
{
- GtkCanvasWaveViewCacheEntry* data;
+ GnomeCanvasWaveViewCacheEntry* data;
gint32 allocated;
gint32 data_size;
gulong start;
gulong end;
};
-GtkCanvasWaveViewCache* gtk_canvas_waveview_cache_new ();
-void gtk_canvas_waveview_cache_destroy (GtkCanvasWaveViewCache*);
+GnomeCanvasWaveViewCache* gnome_canvas_waveview_cache_new ();
+void gnome_canvas_waveview_cache_destroy (GnomeCanvasWaveViewCache*);
-struct _GtkCanvasWaveView
+struct _GnomeCanvasWaveView
{
- GtkCanvasItem item;
+ GnomeCanvasItem item;
- GtkCanvasWaveViewCache *cache;
+ GnomeCanvasWaveViewCache *cache;
gboolean cache_updater;
gint screen_width;
int32_t reload_cache_in_render;
};
-struct _GtkCanvasWaveViewClass {
- GtkCanvasItemClass parent_class;
+struct _GnomeCanvasWaveViewClass {
+ GnomeCanvasItemClass parent_class;
};
-GtkType gtk_canvas_waveview_get_type (void);
+GtkType gnome_canvas_waveview_get_type (void);
-END_GTK_CANVAS_DECLS
+END_GNOME_CANVAS_DECLS
-#endif /* __GTK_CANVAS_WAVEVIEW_H__ */
+#endif /* __GNOME_CANVAS_WAVEVIEW_H__ */
point_grabbed = false;
toplevel = 0;
- _canvas = gtk_canvas_new_aa ();
+ _canvas = gnome_canvas_new_aa ();
canvas = wrap (_canvas);
canvas->size_allocate.connect (mem_fun(*this, &CrossfadeEditor::canvas_allocation));
canvas->set_size_request (425, 200);
- toplevel = gtk_canvas_item_new (gtk_canvas_root (GTK_CANVAS(_canvas)),
- gtk_canvas_simplerect_get_type(),
+ toplevel = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS(_canvas)),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 10.0,
(GtkSignalFunc) _canvas_event,
this);
- fade[Out].line = gtk_canvas_item_new (gtk_canvas_root (GTK_CANVAS(_canvas)),
- gtk_canvas_line_get_type (),
+ fade[Out].line = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS(_canvas)),
+ gnome_canvas_line_get_type (),
"width_pixels", (guint) 1,
"fill_color_rgba", color_map[cCrossfadeEditorLine],
NULL);
- fade[Out].shading = gtk_canvas_item_new (gtk_canvas_root (GTK_CANVAS(_canvas)),
- gtk_canvas_polygon_get_type(),
+ fade[Out].shading = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS(_canvas)),
+ gnome_canvas_polygon_get_type(),
"fill_color_rgba", color_map[cCrossfadeEditorLineShading],
NULL);
- fade[In].line = gtk_canvas_item_new (gtk_canvas_root (GTK_CANVAS(_canvas)),
- gtk_canvas_line_get_type (),
+ fade[In].line = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS(_canvas)),
+ gnome_canvas_line_get_type (),
"width_pixels", (guint) 1,
"fill_color_rgba", color_map[cCrossfadeEditorLine],
NULL);
- fade[In].shading = gtk_canvas_item_new (gtk_canvas_root (GTK_CANVAS(_canvas)),
- gtk_canvas_polygon_get_type(),
+ fade[In].shading = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS(_canvas)),
+ gnome_canvas_polygon_get_type(),
"fill_color_rgba", color_map[cCrossfadeEditorLineShading],
NULL);
}
gint
-CrossfadeEditor::_canvas_event (GtkCanvasItem* item, GdkEvent* event, gpointer data)
+CrossfadeEditor::_canvas_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data)
{
CrossfadeEditor* ed = static_cast<CrossfadeEditor*> (data);
return ed->canvas_event (item, event);
}
gint
-CrossfadeEditor::canvas_event (GtkCanvasItem* item, GdkEvent* event)
+CrossfadeEditor::canvas_event (GnomeCanvasItem* item, GdkEvent* event)
{
switch (event->type) {
case GDK_BUTTON_PRESS:
{
Point* p = new Point;
- p->box = gtk_canvas_item_new (gtk_canvas_root (GTK_CANVAS(_canvas)),
- gtk_canvas_simplerect_get_type(),
+ p->box = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS(_canvas)),
+ gnome_canvas_simplerect_get_type(),
"fill", (gboolean) TRUE,
"fill_color_rgba", color_map[cCrossfadeEditorPointFill],
"outline_color_rgba", color_map[cCrossfadeEditorPointOutline],
double x1 = nx - half_size;
double x2 = nx + half_size;
- gtk_canvas_item_set (box,
+ gnome_canvas_item_set (box,
"x1", x1,
"x2", x2,
"y1", ny - half_size,
CrossfadeEditor::canvas_allocation (GtkAllocation *alloc)
{
if (toplevel) {
- gtk_canvas_item_set (toplevel,
+ gnome_canvas_item_set (toplevel,
"x1", 0.0,
"y1", 0.0,
"x2", (double) _canvas->allocation.width + canvas_border,
NULL);
}
- gtk_canvas_set_scroll_region (GTK_CANVAS(_canvas), 0.0, 0.0,
+ gnome_canvas_set_scroll_region (GNOME_CANVAS(_canvas), 0.0, 0.0,
_canvas->allocation.width,
_canvas->allocation.height);
}
double ht;
- vector<GtkCanvasItem*>::iterator i;
+ vector<GnomeCanvasItem*>::iterator i;
uint32_t n;
ht = _canvas->allocation.height / xfade.in().n_channels();
yoff = n * ht;
- gtk_canvas_item_set ((*i),
+ gnome_canvas_item_set ((*i),
"y", yoff,
"height", ht,
"samples_per_unit", spu,
yoff = n * ht;
- gtk_canvas_item_set ((*i),
+ gnome_canvas_item_set ((*i),
"y", yoff,
"height", ht,
"samples_per_unit", spu,
}
gint
-CrossfadeEditor::_point_event (GtkCanvasItem* item, GdkEvent* event, gpointer data)
+CrossfadeEditor::_point_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data)
{
CrossfadeEditor* ed = static_cast<CrossfadeEditor*> (data);
return ed->point_event (item, event);
}
gint
-CrossfadeEditor::point_event (GtkCanvasItem* item, GdkEvent* event)
+CrossfadeEditor::point_event (GnomeCanvasItem* item, GdkEvent* event)
{
Point* point = static_cast<Point*> (gtk_object_get_data (GTK_OBJECT (item), "point"));
}
gint
-CrossfadeEditor::_curve_event (GtkCanvasItem* item, GdkEvent* event, gpointer data)
+CrossfadeEditor::_curve_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data)
{
CrossfadeEditor* ed = static_cast<CrossfadeEditor*> (data);
return ed->curve_event (item, event);
}
gint
-CrossfadeEditor::curve_event (GtkCanvasItem* item, GdkEvent* event)
+CrossfadeEditor::curve_event (GnomeCanvasItem* item, GdkEvent* event)
{
/* treat it like a toplevel event */
fade[current].normative_curve.get_vector (0, 1.0, vec, npoints);
- GtkCanvasPoints* pts = get_canvas_points ("xfade edit1", npoints);
- GtkCanvasPoints* spts = get_canvas_points ("xfade edit2", npoints + 3);
+ GnomeCanvasPoints* pts = get_canvas_points ("xfade edit1", npoints);
+ GnomeCanvasPoints* spts = get_canvas_points ("xfade edit2", npoints + 3);
/* the shade coordinates *MUST* be in anti-clockwise order.
*/
spts->coords[last_spt - (i*2) + 1] = pts->coords[(i*2)+1];
}
- gtk_canvas_item_set (fade[current].line, "points", pts, NULL);
- gtk_canvas_item_set (fade[current].shading, "points", spts, NULL);
+ gnome_canvas_item_set (fade[current].line, "points", pts, NULL);
+ gnome_canvas_item_set (fade[current].shading, "points", spts, NULL);
- gtk_canvas_points_unref (pts);
- gtk_canvas_points_unref (spts);
+ gnome_canvas_points_unref (pts);
+ gnome_canvas_points_unref (spts);
- for (vector<GtkCanvasItem*>::iterator i = fade[current].waves.begin(); i != fade[current].waves.end(); ++i) {
- gtk_canvas_item_set ((*i), "gain_src", &fade[current].gain_curve, NULL);
+ for (vector<GnomeCanvasItem*>::iterator i = fade[current].waves.begin(); i != fade[current].waves.end(); ++i) {
+ gnome_canvas_item_set ((*i), "gain_src", &fade[current].gain_curve, NULL);
}
}
if (wf == In) {
- for (vector<GtkCanvasItem*>::iterator i = fade[In].waves.begin(); i != fade[In].waves.end(); ++i) {
- gtk_canvas_item_set ((*i), "wave_color", color_map[cSelectedCrossfadeEditorWave], NULL);
+ for (vector<GnomeCanvasItem*>::iterator i = fade[In].waves.begin(); i != fade[In].waves.end(); ++i) {
+ gnome_canvas_item_set ((*i), "wave_color", color_map[cSelectedCrossfadeEditorWave], NULL);
}
- for (vector<GtkCanvasItem*>::iterator i = fade[Out].waves.begin(); i != fade[Out].waves.end(); ++i) {
- gtk_canvas_item_set ((*i), "wave_color", color_map[cCrossfadeEditorWave], NULL);
+ for (vector<GnomeCanvasItem*>::iterator i = fade[Out].waves.begin(); i != fade[Out].waves.end(); ++i) {
+ gnome_canvas_item_set ((*i), "wave_color", color_map[cCrossfadeEditorWave], NULL);
}
- gtk_canvas_item_set (fade[In].line, "fill_color_rgba", color_map[cSelectedCrossfadeEditorLine], NULL);
- gtk_canvas_item_set (fade[Out].line, "fill_color_rgba", color_map[cCrossfadeEditorLine], NULL);
- gtk_canvas_item_hide (fade[Out].shading);
- gtk_canvas_item_show (fade[In].shading);
+ gnome_canvas_item_set (fade[In].line, "fill_color_rgba", color_map[cSelectedCrossfadeEditorLine], NULL);
+ gnome_canvas_item_set (fade[Out].line, "fill_color_rgba", color_map[cCrossfadeEditorLine], NULL);
+ gnome_canvas_item_hide (fade[Out].shading);
+ gnome_canvas_item_show (fade[In].shading);
for (list<Point*>::iterator i = fade[Out].points.begin(); i != fade[Out].points.end(); ++i) {
- gtk_canvas_item_hide ((*i)->box);
+ gnome_canvas_item_hide ((*i)->box);
}
for (list<Point*>::iterator i = fade[In].points.begin(); i != fade[In].points.end(); ++i) {
- gtk_canvas_item_show ((*i)->box);
+ gnome_canvas_item_show ((*i)->box);
}
for (vector<Button*>::iterator i = fade_out_buttons.begin(); i != fade_out_buttons.end(); ++i) {
} else {
- for (vector<GtkCanvasItem*>::iterator i = fade[In].waves.begin(); i != fade[In].waves.end(); ++i) {
- gtk_canvas_item_set ((*i), "wave_color", color_map[cCrossfadeEditorWave], NULL);
+ for (vector<GnomeCanvasItem*>::iterator i = fade[In].waves.begin(); i != fade[In].waves.end(); ++i) {
+ gnome_canvas_item_set ((*i), "wave_color", color_map[cCrossfadeEditorWave], NULL);
}
- for (vector<GtkCanvasItem*>::iterator i = fade[Out].waves.begin(); i != fade[Out].waves.end(); ++i) {
- gtk_canvas_item_set ((*i), "wave_color", color_map[cSelectedCrossfadeEditorWave], NULL);
+ for (vector<GnomeCanvasItem*>::iterator i = fade[Out].waves.begin(); i != fade[Out].waves.end(); ++i) {
+ gnome_canvas_item_set ((*i), "wave_color", color_map[cSelectedCrossfadeEditorWave], NULL);
}
- gtk_canvas_item_set (fade[Out].line, "fill_color_rgba", color_map[cSelectedCrossfadeEditorLine], NULL);
- gtk_canvas_item_set (fade[In].line, "fill_color_rgba", color_map[cCrossfadeEditorLine], NULL);
- gtk_canvas_item_hide (fade[In].shading);
- gtk_canvas_item_show (fade[Out].shading);
+ gnome_canvas_item_set (fade[Out].line, "fill_color_rgba", color_map[cSelectedCrossfadeEditorLine], NULL);
+ gnome_canvas_item_set (fade[In].line, "fill_color_rgba", color_map[cCrossfadeEditorLine], NULL);
+ gnome_canvas_item_hide (fade[In].shading);
+ gnome_canvas_item_show (fade[Out].shading);
for (list<Point*>::iterator i = fade[In].points.begin(); i != fade[In].points.end(); ++i) {
- gtk_canvas_item_hide ((*i)->box);
+ gnome_canvas_item_hide ((*i)->box);
}
for (list<Point*>::iterator i = fade[Out].points.begin(); i != fade[Out].points.end(); ++i) {
- gtk_canvas_item_show ((*i)->box);
+ gnome_canvas_item_show ((*i)->box);
}
for (vector<Button*>::iterator i = fade_out_buttons.begin(); i != fade_out_buttons.end(); ++i) {
if (region.source(n).peaks_ready (bind (mem_fun(*this, &CrossfadeEditor::peaks_ready), ®ion, which))) {
- GtkCanvasItem *wave = gtk_canvas_item_new (gtk_canvas_root (GTK_CANVAS(_canvas)),
- gtk_canvas_waveview_get_type (),
+ GnomeCanvasItem *wave = gnome_canvas_item_new (gnome_canvas_root (GNOME_CANVAS(_canvas)),
+ gnome_canvas_waveview_get_type (),
"data_src", (gpointer) ®ion,
"cache_updater", (gboolean) TRUE,
- "cache", gtk_canvas_waveview_cache_new (),
+ "cache", gnome_canvas_waveview_cache_new (),
"channel", (guint32) n,
"length_function", (gpointer) region_length_from_c,
"sourcefile_length_function", (gpointer) sourcefile_length_from_c,
"wave_color", color,
NULL);
- gtk_canvas_item_lower_to_bottom (wave);
+ gnome_canvas_item_lower_to_bottom (wave);
fade[which].waves.push_back (wave);
}
}
- gtk_canvas_item_lower_to_bottom (toplevel);
+ gnome_canvas_item_lower_to_bottom (toplevel);
}
void
#include <gtkmm/box.h>
#include <gtkmm/button.h>
#include <gtkmm/radiobutton.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <ardour/curve.h>
#include "ardour_dialog.h"
struct Point {
~Point();
- GtkCanvasItem* box;
- GtkCanvasItem* curve;
+ GnomeCanvasItem* box;
+ GnomeCanvasItem* curve;
double x;
double y;
};
GtkWidget* _canvas;
- GtkCanvasItem* toplevel;
+ GnomeCanvasItem* toplevel;
Gtk::Widget* canvas;
struct Half {
- GtkCanvasItem* line;
- GtkCanvasItem* shading;
+ GnomeCanvasItem* line;
+ GnomeCanvasItem* shading;
list<Point*> points;
ARDOUR::Curve normative_curve; /* 0 - 1.0, linear */
ARDOUR::Curve gain_curve; /* 0 - 2.0, gain mapping */
- vector<GtkCanvasItem*> waves;
+ vector<GnomeCanvasItem*> waves;
Half();
};
gint event_handler (GdkEvent*);
- static gint _canvas_event (GtkCanvasItem*, GdkEvent* event, gpointer data);
- static gint _point_event (GtkCanvasItem*, GdkEvent* event, gpointer data);
- static gint _curve_event (GtkCanvasItem*, GdkEvent* event, gpointer data);
+ static gint _canvas_event (GnomeCanvasItem*, GdkEvent* event, gpointer data);
+ static gint _point_event (GnomeCanvasItem*, GdkEvent* event, gpointer data);
+ static gint _curve_event (GnomeCanvasItem*, GdkEvent* event, gpointer data);
- gint canvas_event (GtkCanvasItem*, GdkEvent* event);
- gint point_event (GtkCanvasItem*, GdkEvent* event);
- gint curve_event (GtkCanvasItem*, GdkEvent* event);
+ gint canvas_event (GnomeCanvasItem*, GdkEvent* event);
+ gint point_event (GnomeCanvasItem*, GdkEvent* event);
+ gint curve_event (GnomeCanvasItem*, GdkEvent* event);
void canvas_allocation (GtkAllocation*);
void add_control_point (double x, double y);
sigc::signal<void,CrossfadeView*> CrossfadeView::GoingAway;
-CrossfadeView::CrossfadeView (GtkCanvasGroup *parent,
+CrossfadeView::CrossfadeView (GnomeCanvasGroup *parent,
AudioTimeAxisView &tv,
Crossfade& xf,
double spu,
_valid = true;
_visible = true;
- fade_in = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_line_get_type(),
+ fade_in = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_line_get_type(),
"fill_color_rgba", color_map[cCrossfadeLine],
"width_pixels", (guint) 1,
NULL);
- fade_out = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_line_get_type(),
+ fade_out = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_line_get_type(),
"fill_color_rgba", color_map[cCrossfadeLine],
"width_pixels", (guint) 1,
NULL);
/* no frame around the xfade or overlap rects */
- gtk_canvas_item_set (frame, "outline_what", 0, NULL);
+ gnome_canvas_item_set (frame, "outline_what", 0, NULL);
/* never show the vestigial frame */
- gtk_canvas_item_hide (vestigial_frame);
+ gnome_canvas_item_hide (vestigial_frame);
show_vestigial = false;
gtk_object_set_data (GTK_OBJECT(group), "crossfadeview", this);
active_changed ();
if (pixel_width < 5) {
- gtk_canvas_item_hide (fade_in);
- gtk_canvas_item_hide (fade_out);
+ gnome_canvas_item_hide (fade_in);
+ gnome_canvas_item_hide (fade_out);
}
}
void
CrossfadeView::redraw_curves ()
{
- GtkCanvasPoints* points;
+ GnomeCanvasPoints* points;
int32_t npoints;
float* vec;
npoints = std::min (gdk_screen_width(), npoints);
if (!_visible || !crossfade.active() || npoints < 3) {
- gtk_canvas_item_hide (fade_in);
- gtk_canvas_item_hide (fade_out);
+ gnome_canvas_item_hide (fade_in);
+ gnome_canvas_item_hide (fade_out);
return;
} else {
- gtk_canvas_item_show (fade_in);
- gtk_canvas_item_show (fade_out);
+ gnome_canvas_item_show (fade_in);
+ gnome_canvas_item_show (fade_out);
}
points = get_canvas_points ("xfade edit redraw", npoints);
points->coords[pci++] = i;
points->coords[pci++] = 2.0 + h - (h * vec[i]);
}
- gtk_canvas_item_set (fade_in, "points", points, NULL);
+ gnome_canvas_item_set (fade_in, "points", points, NULL);
crossfade.fade_out().get_vector (0, crossfade.length(), vec, npoints);
for (int i = 0, pci = 0; i < npoints; ++i) {
points->coords[pci++] = i;
points->coords[pci++] = 2.0 + h - (h * vec[i]);
}
- gtk_canvas_item_set (fade_out, "points", points, NULL);
+ gnome_canvas_item_set (fade_out, "points", points, NULL);
delete [] vec;
- gtk_canvas_points_unref (points);
+ gnome_canvas_points_unref (points);
/* XXX this is ugly, but it will have to wait till Crossfades are reimplented
as regions. This puts crossfade views on top of a track, above all regions.
*/
- gtk_canvas_item_raise_to_top (group);
+ gnome_canvas_item_raise_to_top (group);
}
void
CrossfadeView::active_changed ()
{
if (crossfade.active()) {
- gtk_canvas_item_set (frame, "fill_color_rgba", color_map[cActiveCrossfade], NULL);
+ gnome_canvas_item_set (frame, "fill_color_rgba", color_map[cActiveCrossfade], NULL);
} else {
- gtk_canvas_item_set (frame, "fill_color_rgba", color_map[cInactiveCrossfade], NULL);
+ gnome_canvas_item_set (frame, "fill_color_rgba", color_map[cInactiveCrossfade], NULL);
}
redraw_curves ();
void
CrossfadeView::show ()
{
- gtk_canvas_item_show (group);
+ gnome_canvas_item_show (group);
_visible = true;
}
void
CrossfadeView::hide ()
{
- gtk_canvas_item_hide (group);
+ gnome_canvas_item_hide (group);
_visible = false;
}
void
CrossfadeView::fake_hide ()
{
- gtk_canvas_item_hide (group);
+ gnome_canvas_item_hide (group);
}
#include <vector>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <sigc++/signal.h>
#include <ardour/crossfade.h>
struct CrossfadeView : public TimeAxisViewItem
{
- CrossfadeView (GtkCanvasGroup*,
+ CrossfadeView (GnomeCanvasGroup*,
AudioTimeAxisView&,
ARDOUR::Crossfade&,
double initial_samples_per_unit,
double spu;
- GtkCanvasItem *overlap_rect;
- GtkCanvasItem *fade_in;
- GtkCanvasItem *fade_out;
- GtkCanvasItem *active_button;
+ GnomeCanvasItem *overlap_rect;
+ GnomeCanvasItem *fade_in;
+ GnomeCanvasItem *fade_out;
+ GnomeCanvasItem *active_button;
void crossfade_changed (ARDOUR::Change);
void active_changed ();
#include <sigc++/bind.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <pbd/error.h>
#include <gtkmm2ext/gtk_ui.h>
void
Editor::initialize_canvas ()
{
- gtk_canvas_init ();
+ gnome_canvas_init ();
- track_gtk_canvas = gtk_canvas_new_aa ();
+ track_gnome_canvas = gnome_canvas_new_aa ();
/* adjust sensitivity for "picking" items */
- // GTK_CANVAS(track_gtk_canvas)->close_enough = 2;
+ // GNOME_CANVAS(track_gnome_canvas)->close_enough = 2;
- gtk_signal_connect (GTK_OBJECT(gtk_canvas_root (GTK_CANVAS(track_gtk_canvas))), "event",
+ gtk_signal_connect (GTK_OBJECT(gnome_canvas_root (GNOME_CANVAS(track_gnome_canvas))), "event",
(GtkSignalFunc) Editor::_track_canvas_event, this);
- track_canvas = wrap (track_gtk_canvas);
+ track_canvas = wrap (track_gnome_canvas);
track_canvas->set_name ("EditorMainCanvas");
track_canvas->add_events (Gdk::POINTER_MOTION_HINT_MASK);
string fontname = get_font_for_style (N_("VerboseCanvasCursor"));
- verbose_canvas_cursor = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(track_gtk_canvas)),
- gtk_canvas_text_get_type(),
+ verbose_canvas_cursor = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(track_gnome_canvas)),
+ gnome_canvas_text_get_type(),
"font", fontname.c_str(),
"anchor", GTK_ANCHOR_NW,
"fill_color_rgba", color_map[cVerboseCanvasCursor],
/* a group to hold time (measure) lines */
- time_line_group = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(track_gtk_canvas)),
- gtk_canvas_group_get_type(),
+ time_line_group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(track_gnome_canvas)),
+ gnome_canvas_group_get_type(),
"x", 0.0,
"y", 0.0,
NULL);
- cursor_group = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(track_gtk_canvas)),
- gtk_canvas_group_get_type(),
+ cursor_group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(track_gnome_canvas)),
+ gnome_canvas_group_get_type(),
"x", 0.0,
"y", 0.0,
NULL);
- time_gtk_canvas = gtk_canvas_new_aa ();
- time_canvas = wrap (time_gtk_canvas);
+ time_gnome_canvas = gnome_canvas_new_aa ();
+ time_canvas = wrap (time_gnome_canvas);
time_canvas->set_name ("EditorTimeCanvas");
time_canvas->add_events (Gdk::POINTER_MOTION_HINT_MASK);
- meter_group = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(time_gtk_canvas)),
- gtk_canvas_group_get_type(),
+ meter_group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(time_gnome_canvas)),
+ gnome_canvas_group_get_type(),
"x", 0.0,
"y", 0.0,
NULL);
- tempo_group = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(time_gtk_canvas)),
- gtk_canvas_group_get_type(),
+ tempo_group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(time_gnome_canvas)),
+ gnome_canvas_group_get_type(),
"x", 0.0,
"y", timebar_height,
NULL);
- marker_group = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(time_gtk_canvas)),
- gtk_canvas_group_get_type(),
+ marker_group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(time_gnome_canvas)),
+ gnome_canvas_group_get_type(),
"x", 0.0,
"y", timebar_height * 2.0,
NULL);
- range_marker_group = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(time_gtk_canvas)),
- gtk_canvas_group_get_type(),
+ range_marker_group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(time_gnome_canvas)),
+ gnome_canvas_group_get_type(),
"x", 0.0,
"y", timebar_height * 3.0,
NULL);
- transport_marker_group = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(time_gtk_canvas)),
- gtk_canvas_group_get_type(),
+ transport_marker_group = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(time_gnome_canvas)),
+ gnome_canvas_group_get_type(),
"x", 0.0,
"y", timebar_height * 4.0,
NULL);
- tempo_bar = gtk_canvas_item_new (GTK_CANVAS_GROUP(tempo_group),
- gtk_canvas_simplerect_get_type(),
+ tempo_bar = gnome_canvas_item_new (GNOME_CANVAS_GROUP(tempo_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", max_canvas_coordinate,
"fill_color_rgba", color_map[cTempoBar],
"outline_pixels", 0,
NULL);
- meter_bar = gtk_canvas_item_new (GTK_CANVAS_GROUP(meter_group),
- gtk_canvas_simplerect_get_type(),
+ meter_bar = gnome_canvas_item_new (GNOME_CANVAS_GROUP(meter_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", max_canvas_coordinate,
"fill_color_rgba", color_map[cMeterBar],
"outline_pixels", 0,
NULL);
- marker_bar = gtk_canvas_item_new (GTK_CANVAS_GROUP(marker_group),
- gtk_canvas_simplerect_get_type(),
+ marker_bar = gnome_canvas_item_new (GNOME_CANVAS_GROUP(marker_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", max_canvas_coordinate,
"fill_color_rgba", color_map[cMarkerBar],
"outline_pixels", 0,
NULL);
- range_marker_bar = gtk_canvas_item_new (GTK_CANVAS_GROUP(range_marker_group),
- gtk_canvas_simplerect_get_type(),
+ range_marker_bar = gnome_canvas_item_new (GNOME_CANVAS_GROUP(range_marker_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", max_canvas_coordinate,
"fill_color_rgba", color_map[cRangeMarkerBar],
"outline_pixels", 0,
NULL);
- transport_marker_bar = gtk_canvas_item_new (GTK_CANVAS_GROUP(transport_marker_group),
- gtk_canvas_simplerect_get_type(),
+ transport_marker_bar = gnome_canvas_item_new (GNOME_CANVAS_GROUP(transport_marker_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", max_canvas_coordinate,
"outline_pixels", 0,
NULL);
- range_bar_drag_rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(range_marker_group),
- gtk_canvas_simplerect_get_type(),
+ range_bar_drag_rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(range_marker_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
"fill_color_rgba", color_map[cRangeDragBarRectFill],
"outline_color_rgba", color_map[cRangeDragBarRect],
NULL);
- gtk_canvas_item_hide (range_bar_drag_rect);
+ gnome_canvas_item_hide (range_bar_drag_rect);
- transport_bar_drag_rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(transport_marker_group),
- gtk_canvas_simplerect_get_type(),
+ transport_bar_drag_rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(transport_marker_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
"fill_color_rgba", color_map[cTransportDragRectFill],
"outline_color_rgba", color_map[cTransportDragRect],
NULL);
- gtk_canvas_item_hide (transport_bar_drag_rect);
+ gnome_canvas_item_hide (transport_bar_drag_rect);
- marker_drag_line_points = gtk_canvas_points_new (2);
+ marker_drag_line_points = gnome_canvas_points_new (2);
marker_drag_line_points->coords[0] = 0.0;
marker_drag_line_points->coords[1] = 0.0;
marker_drag_line_points->coords[2] = 0.0;
//cerr << "set mdl points, nc = " << marker_drag_line_points->num_points << endl;
- marker_drag_line = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(track_gtk_canvas)),
- gtk_canvas_line_get_type(),
+ marker_drag_line = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(track_gnome_canvas)),
+ gnome_canvas_line_get_type(),
"width_pixels", 1,
"fill_color_rgba", color_map[cMarkerDragLine],
"points", marker_drag_line_points,
NULL);
- gtk_canvas_item_hide (marker_drag_line);
+ gnome_canvas_item_hide (marker_drag_line);
- range_marker_drag_rect = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(track_gtk_canvas)),
- gtk_canvas_simplerect_get_type(),
+ range_marker_drag_rect = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(track_gnome_canvas)),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
"fill_color_rgba", color_map[cRangeDragRectFill],
"outline_color_rgba", color_map[cRangeDragRect],
NULL);
- gtk_canvas_item_hide (range_marker_drag_rect);
+ gnome_canvas_item_hide (range_marker_drag_rect);
- transport_loop_range_rect = gtk_canvas_item_new ((GTK_CANVAS_GROUP(time_line_group)),
- gtk_canvas_simplerect_get_type(),
+ transport_loop_range_rect = gnome_canvas_item_new ((GNOME_CANVAS_GROUP(time_line_group)),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
"outline_color_rgba", color_map[cTransportLoopRect],
"outline_pixels", 1,
NULL);
- gtk_canvas_item_hide (transport_loop_range_rect);
+ gnome_canvas_item_hide (transport_loop_range_rect);
- transport_punch_range_rect = gtk_canvas_item_new ((GTK_CANVAS_GROUP(time_line_group)),
- gtk_canvas_simplerect_get_type(),
+ transport_punch_range_rect = gnome_canvas_item_new ((GNOME_CANVAS_GROUP(time_line_group)),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
"outline_color_rgba", color_map[cTransportPunchRect],
"outline_pixels", 0,
NULL);
- gtk_canvas_item_lower_to_bottom (transport_punch_range_rect);
- gtk_canvas_item_lower_to_bottom (transport_loop_range_rect); // loop on the bottom
- gtk_canvas_item_hide (transport_punch_range_rect);
+ gnome_canvas_item_lower_to_bottom (transport_punch_range_rect);
+ gnome_canvas_item_lower_to_bottom (transport_loop_range_rect); // loop on the bottom
+ gnome_canvas_item_hide (transport_punch_range_rect);
- transport_punchin_line = gtk_canvas_item_new ((GTK_CANVAS_GROUP(time_line_group)),
- gtk_canvas_simplerect_get_type(),
+ transport_punchin_line = gnome_canvas_item_new ((GNOME_CANVAS_GROUP(time_line_group)),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
"outline_color_rgba", color_map[cPunchInLine],
"outline_pixels", 1,
NULL);
- gtk_canvas_item_hide (transport_punchin_line);
+ gnome_canvas_item_hide (transport_punchin_line);
- transport_punchout_line = gtk_canvas_item_new ((GTK_CANVAS_GROUP(time_line_group)),
- gtk_canvas_simplerect_get_type(),
+ transport_punchout_line = gnome_canvas_item_new ((GNOME_CANVAS_GROUP(time_line_group)),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
"outline_color_rgba", color_map[cPunchOutLine],
"outline_pixels", 1,
NULL);
- gtk_canvas_item_hide (transport_punchout_line);
+ gnome_canvas_item_hide (transport_punchout_line);
// used to show zoom mode active zooming
- zoom_rect = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(track_gtk_canvas)),
- gtk_canvas_simplerect_get_type(),
+ zoom_rect = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(track_gnome_canvas)),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
"outline_color_rgba", color_map[cZoomRect],
"outline_pixels", 1,
NULL);
- gtk_canvas_item_hide (zoom_rect);
+ gnome_canvas_item_hide (zoom_rect);
gtk_signal_connect (GTK_OBJECT(zoom_rect), "event",
(GtkSignalFunc) PublicEditor::canvas_zoom_rect_event,
this);
// used as rubberband rect
- rubberband_rect = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(track_gtk_canvas)),
- gtk_canvas_simplerect_get_type(),
+ rubberband_rect = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(track_gnome_canvas)),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
"fill_color_rgba", (guint32) color_map[cRubberBandRectFill],
"outline_pixels", 1,
NULL);
- gtk_canvas_item_hide (rubberband_rect);
+ gnome_canvas_item_hide (rubberband_rect);
/* separator lines */
- tempo_line_points = gtk_canvas_points_new (2);
+ tempo_line_points = gnome_canvas_points_new (2);
tempo_line_points->coords[0] = 0;
tempo_line_points->coords[1] = timebar_height;
tempo_line_points->coords[2] = max_canvas_coordinate;
tempo_line_points->coords[3] = timebar_height;
//cerr << "set tl points, nc = " << tempo_line_points->num_points << endl;
- tempo_line = gtk_canvas_item_new (GTK_CANVAS_GROUP(tempo_group),
- gtk_canvas_line_get_type(),
+ tempo_line = gnome_canvas_item_new (GNOME_CANVAS_GROUP(tempo_group),
+ gnome_canvas_line_get_type(),
"width_pixels", 0,
"fill_color", "black",
"points", tempo_line_points,
// cerr << "tempo line @ " << tempo_line << endl;
- meter_line_points = gtk_canvas_points_new (2);
+ meter_line_points = gnome_canvas_points_new (2);
meter_line_points->coords[0] = 0;
meter_line_points->coords[1] = timebar_height;
meter_line_points->coords[2] = max_canvas_coordinate;
meter_line_points->coords[3] = timebar_height;
// cerr << "set ml points, nc = " << tempo_line_points->num_points << endl;
- meter_line = gtk_canvas_item_new (GTK_CANVAS_GROUP(meter_group),
- gtk_canvas_line_get_type(),
+ meter_line = gnome_canvas_item_new (GNOME_CANVAS_GROUP(meter_group),
+ gnome_canvas_line_get_type(),
"width_pixels", 0,
"fill_color", "black",
"points", meter_line_points,
// cerr << "meter line @ " << tempo_line << endl;
- marker_line_points = gtk_canvas_points_new (2);
+ marker_line_points = gnome_canvas_points_new (2);
marker_line_points->coords[0] = 0;
marker_line_points->coords[1] = timebar_height;
marker_line_points->coords[2] = max_canvas_coordinate;
marker_line_points->coords[3] = timebar_height;
// cerr << "set ml2 points, nc = " << marker_line_points->num_points << endl;
- marker_line = gtk_canvas_item_new (GTK_CANVAS_GROUP(marker_group),
- gtk_canvas_line_get_type(),
+ marker_line = gnome_canvas_item_new (GNOME_CANVAS_GROUP(marker_group),
+ gnome_canvas_line_get_type(),
"width_pixels", 0,
"fill_color", "black",
"points", marker_line_points,
NULL);
// cerr << "set rml points, nc = " << marker_line_points->num_points << endl;
- range_marker_line = gtk_canvas_item_new (GTK_CANVAS_GROUP(range_marker_group),
- gtk_canvas_line_get_type(),
+ range_marker_line = gnome_canvas_item_new (GNOME_CANVAS_GROUP(range_marker_group),
+ gnome_canvas_line_get_type(),
"width_pixels", 0,
"fill_color", "black",
"points", marker_line_points,
NULL);
// cerr << "set tml2 points, nc = " << marker_line_points->num_points << endl;
- transport_marker_line = gtk_canvas_item_new (GTK_CANVAS_GROUP(transport_marker_group),
- gtk_canvas_line_get_type(),
+ transport_marker_line = gnome_canvas_item_new (GNOME_CANVAS_GROUP(transport_marker_group),
+ gnome_canvas_line_get_type(),
"width_pixels", 0,
"fill_color", "black",
"points", marker_line_points,
double time_height = timebar_height * 5;
double time_width = FLT_MAX/frames_per_unit;
- gtk_canvas_set_scroll_region (GTK_CANVAS(time_gtk_canvas), 0.0, 0.0, time_width, time_height);
+ gnome_canvas_set_scroll_region (GNOME_CANVAS(time_gnome_canvas), 0.0, 0.0, time_width, time_height);
edit_cursor = new Cursor (*this, "blue", (GtkSignalFunc) _canvas_edit_cursor_event);
playhead_cursor = new Cursor (*this, "red", (GtkSignalFunc) _canvas_playhead_cursor_event);
strcpy (txt, _(txt1));
strcat (txt, _(txt2));
- first_action_message = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(track_gtk_canvas)),
- gtk_canvas_text_get_type(),
+ first_action_message = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(track_gnome_canvas)),
+ gnome_canvas_text_get_type(),
"font", fontname.c_str(),
"fill_color_rgba", color_map[cFirstActionMessage],
"x", (gdouble) (canvas_width - width) / 2.0,
/* center it */
- gtk_canvas_item_set (first_action_message,
+ gnome_canvas_item_set (first_action_message,
"x", (gdouble) (canvas_width - width) / 2.0,
"y", (gdouble) (canvas_height/2.0) - (2.0 * (ascent+descent)),
NULL);
canvas_alloc_height = alloc->height;
canvas_alloc_width = alloc->width;
} else {
- canvas_alloc_height = track_gtk_canvas->allocation.height;
- canvas_alloc_width = track_gtk_canvas->allocation.width;
+ canvas_alloc_height = track_gnome_canvas->allocation.height;
+ canvas_alloc_width = track_gnome_canvas->allocation.width;
}
canvas_height = max (canvas_height, canvas_alloc_height);
- gtk_canvas_set_scroll_region (GTK_CANVAS(track_gtk_canvas), 0.0, 0.0,
+ gnome_canvas_set_scroll_region (GNOME_CANVAS(track_gnome_canvas), 0.0, 0.0,
max (last_canvas_unit, canvas_alloc_width),
canvas_height);
if (marker_drag_line) {
marker_drag_line_points->coords[3] = canvas_height;
// cerr << "set mlA points, nc = " << marker_drag_line_points->num_points << endl;
- gtk_canvas_item_set (marker_drag_line, "points", marker_drag_line_points, NULL);
+ gnome_canvas_item_set (marker_drag_line, "points", marker_drag_line_points, NULL);
}
if (range_marker_drag_rect) {
- gtk_canvas_item_set (range_marker_drag_rect, "y1", 0.0, "y2", (double) canvas_height, NULL);
+ gnome_canvas_item_set (range_marker_drag_rect, "y1", 0.0, "y2", (double) canvas_height, NULL);
}
if (transport_loop_range_rect) {
- gtk_canvas_item_set (transport_loop_range_rect, "y1", 0.0, "y2", (double) canvas_height, NULL);
+ gnome_canvas_item_set (transport_loop_range_rect, "y1", 0.0, "y2", (double) canvas_height, NULL);
}
if (transport_punch_range_rect) {
- gtk_canvas_item_set (transport_punch_range_rect, "y1", 0.0, "y2", (double) canvas_height, NULL);
+ gnome_canvas_item_set (transport_punch_range_rect, "y1", 0.0, "y2", (double) canvas_height, NULL);
}
if (transport_punchin_line) {
- gtk_canvas_item_set (transport_punchin_line, "y1", 0.0, "y2", (double) canvas_height, NULL);
+ gnome_canvas_item_set (transport_punchin_line, "y1", 0.0, "y2", (double) canvas_height, NULL);
}
if (transport_punchout_line) {
- gtk_canvas_item_set (transport_punchout_line, "y1", 0.0, "y2", (double) canvas_height, NULL);
+ gnome_canvas_item_set (transport_punchout_line, "y1", 0.0, "y2", (double) canvas_height, NULL);
}
session = t;
if (first_action_message) {
- gtk_canvas_item_hide (first_action_message);
+ gnome_canvas_item_hide (first_action_message);
}
flush_track_canvas();
}
void
-Editor::popup_fade_context_menu (int button, int32_t time, GtkCanvasItem* item, ItemType item_type)
+Editor::popup_fade_context_menu (int button, int32_t time, GnomeCanvasItem* item, ItemType item_type)
{
using namespace Menu_Helpers;
AudioRegionView* arv = static_cast<AudioRegionView*> (gtk_object_get_data (GTK_OBJECT(item), "regionview"));
double wx;
double wy;
- gtk_canvas_window_to_world (GTK_CANVAS(track_gtk_canvas), (double) x, (double) y, &wx, &wy);
+ gnome_canvas_window_to_world (GNOME_CANVAS(track_gnome_canvas), (double) x, (double) y, &wx, &wy);
ev.type = GDK_BUTTON_RELEASE;
ev.button.x = wx;
out this method entirely
*/
- //gtk_canvas_update_now (GTK_CANVAS(track_gtk_canvas));
+ //gnome_canvas_update_now (GNOME_CANVAS(track_gnome_canvas));
//gtk_main_iteration ();
}
// leads to a mismatch between actual layering
// and visual layering. resolution required ....
//
- // gtk_canvas_item_raise_to_top (clicked_regionview->get_canvas_group());
- // gtk_canvas_item_raise_to_top (clicked_regionview->get_time_axis_view().canvas_display);
+ // gnome_canvas_item_raise_to_top (clicked_regionview->get_canvas_group());
+ // gnome_canvas_item_raise_to_top (clicked_regionview->get_time_axis_view().canvas_display);
if (clicked_regionview->get_selected()) {
/* no commit necessary: we are the one selected. */
void
Editor::show_verbose_canvas_cursor ()
{
- gtk_canvas_item_raise_to_top (verbose_canvas_cursor);
- gtk_canvas_item_show (verbose_canvas_cursor);
+ gnome_canvas_item_raise_to_top (verbose_canvas_cursor);
+ gnome_canvas_item_show (verbose_canvas_cursor);
verbose_cursor_visible = true;
}
void
Editor::hide_verbose_canvas_cursor ()
{
- gtk_canvas_item_hide (verbose_canvas_cursor);
+ gnome_canvas_item_hide (verbose_canvas_cursor);
verbose_cursor_visible = false;
}
/* XXX get origin of canvas relative to root window,
add x and y and check compared to gdk_screen_{width,height}
*/
- gtk_canvas_item_set (verbose_canvas_cursor, "text", txt.c_str(), "x", x, "y", y, NULL);
+ gnome_canvas_item_set (verbose_canvas_cursor, "text", txt.c_str(), "x", x, "y", y, NULL);
}
void
Editor::set_verbose_canvas_cursor_text (string txt)
{
- gtk_canvas_item_set (verbose_canvas_cursor, "text", txt.c_str(), NULL);
+ gnome_canvas_item_set (verbose_canvas_cursor, "text", txt.c_str(), NULL);
}
gint
#include <gtkmm.h>
#include <gtkmm/layout.h>
-#include <gtk-canvas.h>
-#include <gtk-canvas/gtk-canvas-util.h>
+#include <libgnomecanvas/libgnomecanvas.h>
+#include <libgnomecanvas/gnome-canvas-util.h>
#include <gtkmm2ext/selector.h>
#include <gtkmm2ext/click_box.h>
*/
if (pixel >= 0) {
- return (jack_nframes_t) rint (pixel * frames_per_unit * GTK_CANVAS(track_gtk_canvas)->pixels_per_unit);
+ return (jack_nframes_t) rint (pixel * frames_per_unit * GNOME_CANVAS(track_gnome_canvas)->pixels_per_unit);
} else {
return 0;
}
}
gulong frame_to_pixel (jack_nframes_t frame) {
- return (gulong) rint ((frame / (frames_per_unit * GTK_CANVAS(track_gtk_canvas)->pixels_per_unit)));
+ return (gulong) rint ((frame / (frames_per_unit * GNOME_CANVAS(track_gnome_canvas)->pixels_per_unit)));
}
/* selection */
void refresh_location_display_internal (ARDOUR::Locations::LocationList&);
void add_new_location (ARDOUR::Location *);
void location_gone (ARDOUR::Location *);
- void remove_marker (GtkCanvasItem*, GdkEvent*);
+ void remove_marker (GnomeCanvasItem*, GdkEvent*);
gint really_remove_marker (ARDOUR::Location* loc);
uint32_t location_marker_color;
typedef map<ARDOUR::Location*,LocationMarkers *> LocationMarkerMap;
LocationMarkerMap location_markers;
- void hide_marker (GtkCanvasItem*, GdkEvent*);
+ void hide_marker (GnomeCanvasItem*, GdkEvent*);
void clear_marker_display ();
void mouse_add_new_marker (jack_nframes_t where);
GdkCursor *current_canvas_cursor;
- GtkWidget *track_gtk_canvas;
- GtkWidget *time_gtk_canvas;
+ GtkWidget *track_gnome_canvas;
+ GtkWidget *time_gnome_canvas;
Gtk::Widget *track_canvas;
Gtk::Widget *time_canvas;
- GtkCanvasItem* first_action_message;
- GtkCanvasItem *verbose_canvas_cursor;
+ GnomeCanvasItem* first_action_message;
+ GnomeCanvasItem *verbose_canvas_cursor;
bool verbose_cursor_visible;
void session_control_changed (ARDOUR::Session::ControlType);
void queue_session_control_changed (ARDOUR::Session::ControlType);
- gint track_canvas_motion (GtkCanvasItem*, GdkEvent*);
+ gint track_canvas_motion (GnomeCanvasItem*, GdkEvent*);
void set_verbose_canvas_cursor (string, double x, double y);
void set_verbose_canvas_cursor_text (string);
void show_verbose_canvas_cursor();
Gtk::EventBox track_canvas_event_box;
Gtk::EventBox time_button_event_box;
- GtkCanvasItem *minsec_group;
- GtkCanvasItem *bbt_group;
- GtkCanvasItem *smpte_group;
- GtkCanvasItem *frame_group;
- GtkCanvasItem *tempo_group;
- GtkCanvasItem *meter_group;
- GtkCanvasItem *marker_group;
- GtkCanvasItem *range_marker_group;
- GtkCanvasItem *transport_marker_group;
+ GnomeCanvasItem *minsec_group;
+ GnomeCanvasItem *bbt_group;
+ GnomeCanvasItem *smpte_group;
+ GnomeCanvasItem *frame_group;
+ GnomeCanvasItem *tempo_group;
+ GnomeCanvasItem *meter_group;
+ GnomeCanvasItem *marker_group;
+ GnomeCanvasItem *range_marker_group;
+ GnomeCanvasItem *transport_marker_group;
enum {
ruler_metric_smpte = 0,
Gtk::Menu *editor_ruler_menu;
- GtkCanvasItem *tempo_bar;
- GtkCanvasItem *meter_bar;
- GtkCanvasItem *marker_bar;
- GtkCanvasItem *range_marker_bar;
+ GnomeCanvasItem *tempo_bar;
+ GnomeCanvasItem *meter_bar;
+ GnomeCanvasItem *marker_bar;
+ GnomeCanvasItem *range_marker_bar;
- GtkCanvasItem *transport_marker_bar;
+ GnomeCanvasItem *transport_marker_bar;
- GtkCanvasItem *tempo_line;
- GtkCanvasItem *meter_line;
- GtkCanvasItem *marker_line;
- GtkCanvasItem *range_marker_line;
- GtkCanvasItem *transport_marker_line;
-
- GtkCanvasPoints *tempo_line_points;
- GtkCanvasPoints *meter_line_points;
- GtkCanvasPoints *marker_line_points;
- GtkCanvasPoints *range_marker_line_points;
- GtkCanvasPoints *transport_marker_line_points;
+ GnomeCanvasItem *tempo_line;
+ GnomeCanvasItem *meter_line;
+ GnomeCanvasItem *marker_line;
+ GnomeCanvasItem *range_marker_line;
+ GnomeCanvasItem *transport_marker_line;
+
+ GnomeCanvasPoints *tempo_line_points;
+ GnomeCanvasPoints *meter_line_points;
+ GnomeCanvasPoints *marker_line_points;
+ GnomeCanvasPoints *range_marker_line_points;
+ GnomeCanvasPoints *transport_marker_line_points;
Gtk::Label minsec_label;
Gtk::Label bbt_label;
struct Cursor {
Editor& editor;
- GtkCanvasPoints *points;
- GtkCanvasItem *canvas_item;
+ GnomeCanvasPoints *points;
+ GnomeCanvasItem *canvas_item;
jack_nframes_t current_frame;
GtkSignalFunc callback;
double length;
Cursor* playhead_cursor;
Cursor* edit_cursor;
- GtkCanvasItem* cursor_group;
+ GnomeCanvasItem* cursor_group;
void cursor_to_next_region_point (Cursor*, ARDOUR::RegionPoint);
void cursor_to_previous_region_point (Cursor*, ARDOUR::RegionPoint);
jack_nframes_t cut_buffer_start;
jack_nframes_t cut_buffer_length;
- gint typed_event (GtkCanvasItem*, GdkEvent*, ItemType);
- gint button_press_handler (GtkCanvasItem*, GdkEvent*, ItemType);
- gint button_release_handler (GtkCanvasItem*, GdkEvent*, ItemType);
- gint motion_handler (GtkCanvasItem*, GdkEvent*, ItemType);
- gint enter_handler (GtkCanvasItem*, GdkEvent*, ItemType);
- gint leave_handler (GtkCanvasItem*, GdkEvent*, ItemType);
+ gint typed_event (GnomeCanvasItem*, GdkEvent*, ItemType);
+ gint button_press_handler (GnomeCanvasItem*, GdkEvent*, ItemType);
+ gint button_release_handler (GnomeCanvasItem*, GdkEvent*, ItemType);
+ gint motion_handler (GnomeCanvasItem*, GdkEvent*, ItemType);
+ gint enter_handler (GnomeCanvasItem*, GdkEvent*, ItemType);
+ gint leave_handler (GnomeCanvasItem*, GdkEvent*, ItemType);
/* KEYMAP HANDLING */
void queue_route_list_reordered (gint row, gint col);
struct DragInfo {
- GtkCanvasItem* item;
+ GnomeCanvasItem* item;
void* data;
jack_nframes_t last_frame_position;
int32_t pointer_frame_offset;
double cumulative_y_drag;
double current_pointer_x;
double current_pointer_y;
- void (Editor::*motion_callback)(GtkCanvasItem*, GdkEvent*);
- void (Editor::*finished_callback)(GtkCanvasItem*, GdkEvent*);
+ void (Editor::*motion_callback)(GnomeCanvasItem*, GdkEvent*);
+ void (Editor::*finished_callback)(GnomeCanvasItem*, GdkEvent*);
TimeAxisView* last_trackview;
bool x_constrained;
bool copy;
LineDragInfo current_line_drag_info;
void start_grab (GdkEvent*, GdkCursor* cursor = 0);
- bool end_grab (GtkCanvasItem*, GdkEvent*);
+ bool end_grab (GnomeCanvasItem*, GdkEvent*);
Gtk::Menu fade_context_menu;
- void popup_fade_context_menu (int, int, GtkCanvasItem*, ItemType);
-
- void start_fade_in_grab (GtkCanvasItem*, GdkEvent*);
- void start_fade_out_grab (GtkCanvasItem*, GdkEvent*);
- void fade_in_drag_motion_callback (GtkCanvasItem*, GdkEvent*);
- void fade_out_drag_motion_callback (GtkCanvasItem*, GdkEvent*);
- void fade_in_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
- void fade_out_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
+ void popup_fade_context_menu (int, int, GnomeCanvasItem*, ItemType);
+
+ void start_fade_in_grab (GnomeCanvasItem*, GdkEvent*);
+ void start_fade_out_grab (GnomeCanvasItem*, GdkEvent*);
+ void fade_in_drag_motion_callback (GnomeCanvasItem*, GdkEvent*);
+ void fade_out_drag_motion_callback (GnomeCanvasItem*, GdkEvent*);
+ void fade_in_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
+ void fade_out_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
std::set<ARDOUR::Playlist*> motion_frozen_playlists;
- void region_drag_motion_callback (GtkCanvasItem*, GdkEvent*);
- void region_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
- void region_copy_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
-
- void cursor_drag_motion_callback (GtkCanvasItem*, GdkEvent*);
- void cursor_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
- void marker_drag_motion_callback (GtkCanvasItem*, GdkEvent*);
- void marker_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
- void control_point_drag_motion_callback (GtkCanvasItem*, GdkEvent*);
- void control_point_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
- void line_drag_motion_callback (GtkCanvasItem*, GdkEvent*);
- void line_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
-
- void tempo_marker_drag_motion_callback (GtkCanvasItem*, GdkEvent*);
- void tempo_marker_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
- void meter_marker_drag_motion_callback (GtkCanvasItem*, GdkEvent*);
- void meter_marker_drag_finished_callback (GtkCanvasItem*, GdkEvent*);
-
- gint mouse_rename_region (GtkCanvasItem*, GdkEvent*);
-
- void start_region_grab (GtkCanvasItem*, GdkEvent*);
- void start_region_copy_grab (GtkCanvasItem*, GdkEvent*);
- void start_region_brush_grab (GtkCanvasItem*, GdkEvent*);
- void start_selection_grab (GtkCanvasItem*, GdkEvent*);
- void start_cursor_grab (GtkCanvasItem*, GdkEvent*);
- void start_marker_grab (GtkCanvasItem*, GdkEvent*);
- void start_control_point_grab (GtkCanvasItem*, GdkEvent*);
- void start_line_grab_from_regionview (GtkCanvasItem*, GdkEvent*);
- void start_line_grab_from_line (GtkCanvasItem*, GdkEvent*);
+ void region_drag_motion_callback (GnomeCanvasItem*, GdkEvent*);
+ void region_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
+ void region_copy_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
+
+ void cursor_drag_motion_callback (GnomeCanvasItem*, GdkEvent*);
+ void cursor_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
+ void marker_drag_motion_callback (GnomeCanvasItem*, GdkEvent*);
+ void marker_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
+ void control_point_drag_motion_callback (GnomeCanvasItem*, GdkEvent*);
+ void control_point_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
+ void line_drag_motion_callback (GnomeCanvasItem*, GdkEvent*);
+ void line_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
+
+ void tempo_marker_drag_motion_callback (GnomeCanvasItem*, GdkEvent*);
+ void tempo_marker_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
+ void meter_marker_drag_motion_callback (GnomeCanvasItem*, GdkEvent*);
+ void meter_marker_drag_finished_callback (GnomeCanvasItem*, GdkEvent*);
+
+ gint mouse_rename_region (GnomeCanvasItem*, GdkEvent*);
+
+ void start_region_grab (GnomeCanvasItem*, GdkEvent*);
+ void start_region_copy_grab (GnomeCanvasItem*, GdkEvent*);
+ void start_region_brush_grab (GnomeCanvasItem*, GdkEvent*);
+ void start_selection_grab (GnomeCanvasItem*, GdkEvent*);
+ void start_cursor_grab (GnomeCanvasItem*, GdkEvent*);
+ void start_marker_grab (GnomeCanvasItem*, GdkEvent*);
+ void start_control_point_grab (GnomeCanvasItem*, GdkEvent*);
+ void start_line_grab_from_regionview (GnomeCanvasItem*, GdkEvent*);
+ void start_line_grab_from_line (GnomeCanvasItem*, GdkEvent*);
void start_line_grab (AutomationLine *, GdkEvent*);
- void start_tempo_marker_grab (GtkCanvasItem*, GdkEvent*);
- void start_meter_marker_grab (GtkCanvasItem*, GdkEvent*);
+ void start_tempo_marker_grab (GnomeCanvasItem*, GdkEvent*);
+ void start_meter_marker_grab (GnomeCanvasItem*, GdkEvent*);
void region_view_item_click (AudioRegionView&, GdkEventButton*);
- void remove_gain_control_point (GtkCanvasItem*, GdkEvent*);
- void remove_control_point (GtkCanvasItem*, GdkEvent*);
+ void remove_gain_control_point (GnomeCanvasItem*, GdkEvent*);
+ void remove_control_point (GnomeCanvasItem*, GdkEvent*);
void mouse_brush_insert_region (AudioRegionView*, jack_nframes_t pos);
void brush (jack_nframes_t);
/* static versions of these are public in PublicEditor */
- gint _canvas_crossfade_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_fade_in_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_fade_in_handle_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_fade_out_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_fade_out_handle_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_region_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_region_view_name_highlight_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_region_view_name_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_stream_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_automation_track_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_zoom_rect_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_selection_rect_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_selection_start_trim_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_selection_end_trim_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_control_point_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_line_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_tempo_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_meter_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_tempo_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_meter_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_range_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_transport_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint _canvas_imageframe_item_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data) ;
- gint _canvas_imageframe_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data) ;
- gint _canvas_imageframe_start_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- gint _canvas_imageframe_end_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- gint _canvas_marker_time_axis_view_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- gint _canvas_markerview_item_view_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- gint _canvas_markerview_start_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- gint _canvas_markerview_end_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
+ gint _canvas_crossfade_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_fade_in_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_fade_in_handle_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_fade_out_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_fade_out_handle_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_region_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_region_view_name_highlight_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_region_view_name_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_stream_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_automation_track_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_zoom_rect_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_selection_rect_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_selection_start_trim_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_selection_end_trim_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_control_point_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_line_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_tempo_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_meter_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_tempo_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_meter_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_range_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_transport_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint _canvas_imageframe_item_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data) ;
+ gint _canvas_imageframe_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data) ;
+ gint _canvas_imageframe_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ gint _canvas_imageframe_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ gint _canvas_marker_time_axis_view_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ gint _canvas_markerview_item_view_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ gint _canvas_markerview_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ gint _canvas_markerview_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
/* now the real things */
- gint canvas_crossfade_view_event (GtkCanvasItem* item, GdkEvent* event, CrossfadeView*);
- gint canvas_fade_in_event (GtkCanvasItem* item, GdkEvent* event, AudioRegionView*);
- gint canvas_fade_in_handle_event (GtkCanvasItem* item, GdkEvent* event, AudioRegionView*);
- gint canvas_fade_out_event (GtkCanvasItem* item, GdkEvent* event, AudioRegionView*);
- gint canvas_fade_out_handle_event (GtkCanvasItem* item, GdkEvent* event, AudioRegionView*);
- gint canvas_region_view_event (GtkCanvasItem* item, GdkEvent* event, AudioRegionView*);
- gint canvas_stream_view_event (GtkCanvasItem* item, GdkEvent* event, AudioTimeAxisView*);
- gint canvas_automation_track_event (GtkCanvasItem* item, GdkEvent* event, AutomationTimeAxisView*);
- gint canvas_marker_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_zoom_rect_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_selection_rect_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_selection_start_trim_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_selection_end_trim_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_control_point_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_line_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_tempo_marker_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_meter_marker_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_tempo_bar_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_meter_bar_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_marker_bar_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_range_marker_bar_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_transport_marker_bar_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_region_view_name_highlight_event (GtkCanvasItem* item, GdkEvent* event);
- gint canvas_region_view_name_event (GtkCanvasItem* item, GdkEvent* event);
+ gint canvas_crossfade_view_event (GnomeCanvasItem* item, GdkEvent* event, CrossfadeView*);
+ gint canvas_fade_in_event (GnomeCanvasItem* item, GdkEvent* event, AudioRegionView*);
+ gint canvas_fade_in_handle_event (GnomeCanvasItem* item, GdkEvent* event, AudioRegionView*);
+ gint canvas_fade_out_event (GnomeCanvasItem* item, GdkEvent* event, AudioRegionView*);
+ gint canvas_fade_out_handle_event (GnomeCanvasItem* item, GdkEvent* event, AudioRegionView*);
+ gint canvas_region_view_event (GnomeCanvasItem* item, GdkEvent* event, AudioRegionView*);
+ gint canvas_stream_view_event (GnomeCanvasItem* item, GdkEvent* event, AudioTimeAxisView*);
+ gint canvas_automation_track_event (GnomeCanvasItem* item, GdkEvent* event, AutomationTimeAxisView*);
+ gint canvas_marker_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_zoom_rect_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_selection_rect_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_selection_start_trim_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_selection_end_trim_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_control_point_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_line_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_tempo_marker_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_meter_marker_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_tempo_bar_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_meter_bar_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_range_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_transport_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_region_view_name_highlight_event (GnomeCanvasItem* item, GdkEvent* event);
+ gint canvas_region_view_name_event (GnomeCanvasItem* item, GdkEvent* event);
/* these are not publically accessible, but we still need the static versions
till we use Gnome::Canvas.
*/
- static gint _canvas_copy_region_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint canvas_copy_region_event (GtkCanvasItem* item, GdkEvent* event);
+ static gint _canvas_copy_region_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint canvas_copy_region_event (GnomeCanvasItem* item, GdkEvent* event);
- static gint _canvas_playhead_cursor_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint canvas_playhead_cursor_event (GtkCanvasItem* item, GdkEvent* event);
+ static gint _canvas_playhead_cursor_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint canvas_playhead_cursor_event (GnomeCanvasItem* item, GdkEvent* event);
- static gint _canvas_edit_cursor_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint canvas_edit_cursor_event (GtkCanvasItem* item, GdkEvent* event);
+ static gint _canvas_edit_cursor_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint canvas_edit_cursor_event (GnomeCanvasItem* item, GdkEvent* event);
- static gint _track_canvas_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- gint track_canvas_event (GtkCanvasItem* item, GdkEvent* event);
+ static gint _track_canvas_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ gint track_canvas_event (GnomeCanvasItem* item, GdkEvent* event);
gint track_canvas_button_press_event (GdkEventButton *);
gint track_canvas_button_release_event (GdkEventButton *);
ARDOUR::TempoMap::BBTPointList *current_bbt_points;
- typedef vector<GtkCanvasItem*> TimeLineList;
+ typedef vector<GnomeCanvasItem*> TimeLineList;
TimeLineList free_measure_lines;
TimeLineList used_measure_lines;
- GtkCanvasItem* time_line_group;
- GtkCanvasItem* get_time_line ();
+ GnomeCanvasItem* time_line_group;
+ GnomeCanvasItem* get_time_line ();
void hide_measures ();
void draw_measures ();
void draw_time_bars ();
void mouse_add_new_tempo_event (jack_nframes_t where);
void mouse_add_new_meter_event (jack_nframes_t where);
- void remove_tempo_marker (GtkCanvasItem*);
- void remove_meter_marker (GtkCanvasItem*);
+ void remove_tempo_marker (GnomeCanvasItem*);
+ void remove_meter_marker (GnomeCanvasItem*);
gint real_remove_tempo_marker (ARDOUR::TempoSection*);
gint real_remove_meter_marker (ARDOUR::MeterSection*);
void edit_tempo_section (ARDOUR::TempoSection*);
void edit_meter_section (ARDOUR::MeterSection*);
- void edit_tempo_marker (GtkCanvasItem*);
- void edit_meter_marker (GtkCanvasItem*);
+ void edit_tempo_marker (GnomeCanvasItem*);
+ void edit_meter_marker (GnomeCanvasItem*);
void marker_menu_edit ();
void marker_menu_remove ();
void update_loop_range_view (bool visibility=false);
void update_punch_range_view (bool visibility=false);
gint new_transport_marker_menu_popdown (GdkEventAny*);
- void marker_context_menu (GdkEventButton*, GtkCanvasItem*);
- void tm_marker_context_menu (GdkEventButton*, GtkCanvasItem*);
- void transport_marker_context_menu (GdkEventButton*, GtkCanvasItem*);
- void new_transport_marker_context_menu (GdkEventButton*, GtkCanvasItem*);
+ void marker_context_menu (GdkEventButton*, GnomeCanvasItem*);
+ void tm_marker_context_menu (GdkEventButton*, GnomeCanvasItem*);
+ void transport_marker_context_menu (GdkEventButton*, GnomeCanvasItem*);
+ void new_transport_marker_context_menu (GdkEventButton*, GnomeCanvasItem*);
void build_marker_menu ();
void build_tm_marker_menu ();
void build_transport_marker_menu ();
Gtk::Menu* marker_menu;
Gtk::Menu* transport_marker_menu;
Gtk::Menu* new_transport_marker_menu;
- GtkCanvasItem* marker_menu_item;
+ GnomeCanvasItem* marker_menu_item;
typedef list<Marker*> Marks;
Marks metric_marks;
SelectionMove
} selection_op;
- void start_selection_op (GtkCanvasItem* item, GdkEvent* event, SelectionOp);
- void drag_selection (GtkCanvasItem* item, GdkEvent* event);
- void end_selection_op (GtkCanvasItem* item, GdkEvent* event);
+ void start_selection_op (GnomeCanvasItem* item, GdkEvent* event, SelectionOp);
+ void drag_selection (GnomeCanvasItem* item, GdkEvent* event);
+ void end_selection_op (GnomeCanvasItem* item, GdkEvent* event);
void cancel_selection ();
void region_selection_op (void (ARDOUR::Region::*pmf)(void));
CreateTransportMarker
} range_marker_op;
- void start_range_markerbar_op (GtkCanvasItem* item, GdkEvent* event, RangeMarkerOp);
- void drag_range_markerbar_op (GtkCanvasItem* item, GdkEvent* event);
- void end_range_markerbar_op (GtkCanvasItem* item, GdkEvent* event);
+ void start_range_markerbar_op (GnomeCanvasItem* item, GdkEvent* event, RangeMarkerOp);
+ void drag_range_markerbar_op (GnomeCanvasItem* item, GdkEvent* event);
+ void end_range_markerbar_op (GnomeCanvasItem* item, GdkEvent* event);
- GtkCanvasItem *range_bar_drag_rect;
- GtkCanvasItem *transport_bar_drag_rect;
- GtkCanvasItem *marker_drag_line;
- GtkCanvasPoints *marker_drag_line_points;
- GtkCanvasItem *range_marker_drag_rect;
+ GnomeCanvasItem *range_bar_drag_rect;
+ GnomeCanvasItem *transport_bar_drag_rect;
+ GnomeCanvasItem *marker_drag_line;
+ GnomeCanvasPoints *marker_drag_line_points;
+ GnomeCanvasItem *range_marker_drag_rect;
void update_marker_drag_item (ARDOUR::Location *);
- GtkCanvasItem *transport_bar_range_rect;
- GtkCanvasItem *transport_bar_preroll_rect;
- GtkCanvasItem *transport_bar_postroll_rect;
- GtkCanvasItem *transport_loop_range_rect;
- GtkCanvasItem *transport_punch_range_rect;
- GtkCanvasItem *transport_punchin_line;
- GtkCanvasItem *transport_punchout_line;
- GtkCanvasItem *transport_preroll_rect;
- GtkCanvasItem *transport_postroll_rect;
+ GnomeCanvasItem *transport_bar_range_rect;
+ GnomeCanvasItem *transport_bar_preroll_rect;
+ GnomeCanvasItem *transport_bar_postroll_rect;
+ GnomeCanvasItem *transport_loop_range_rect;
+ GnomeCanvasItem *transport_punch_range_rect;
+ GnomeCanvasItem *transport_punchin_line;
+ GnomeCanvasItem *transport_punchout_line;
+ GnomeCanvasItem *transport_preroll_rect;
+ GnomeCanvasItem *transport_postroll_rect;
ARDOUR::Location* transport_loop_location();
ARDOUR::Location* transport_punch_location();
/* object rubberband select process */
- void start_rubberband_select (GtkCanvasItem* item, GdkEvent* event);
- void drag_rubberband_select (GtkCanvasItem* item, GdkEvent* event);
- void end_rubberband_select (GtkCanvasItem* item, GdkEvent* event);
+ void start_rubberband_select (GnomeCanvasItem* item, GdkEvent* event);
+ void drag_rubberband_select (GnomeCanvasItem* item, GdkEvent* event);
+ void end_rubberband_select (GnomeCanvasItem* item, GdkEvent* event);
bool select_all_within (jack_nframes_t start, jack_nframes_t end, gdouble topy, gdouble boty, bool add);
- GtkCanvasItem *rubberband_rect;
+ GnomeCanvasItem *rubberband_rect;
/* mouse zoom process */
- void start_mouse_zoom (GtkCanvasItem* item, GdkEvent* event);
- void drag_mouse_zoom (GtkCanvasItem* item, GdkEvent* event);
- void end_mouse_zoom (GtkCanvasItem* item, GdkEvent* event);
+ void start_mouse_zoom (GnomeCanvasItem* item, GdkEvent* event);
+ void drag_mouse_zoom (GnomeCanvasItem* item, GdkEvent* event);
+ void end_mouse_zoom (GnomeCanvasItem* item, GdkEvent* event);
- GtkCanvasItem *zoom_rect;
+ GnomeCanvasItem *zoom_rect;
void reposition_zoom_rect (jack_nframes_t start, jack_nframes_t end);
/* diskstream/route display management */
ContentsTrim,
} trim_op;
- void start_trim (GtkCanvasItem*, GdkEvent*);
+ void start_trim (GnomeCanvasItem*, GdkEvent*);
void point_trim (GdkEvent*);
- void trim_motion_callback (GtkCanvasItem*, GdkEvent*);
+ void trim_motion_callback (GnomeCanvasItem*, GdkEvent*);
void single_contents_trim (AudioRegionView&, jack_nframes_t, bool, bool, bool);
void single_start_trim (AudioRegionView&, jack_nframes_t, bool, bool);
void single_end_trim (AudioRegionView&, jack_nframes_t, bool, bool);
- void trim_finished_callback (GtkCanvasItem*, GdkEvent*);
+ void trim_finished_callback (GnomeCanvasItem*, GdkEvent*);
void thaw_region_after_trim (AudioRegionView& rv);
void trim_region_to_edit_cursor ();
jack_nframes_t event_frame (GdkEvent*, double* px = 0, double* py = 0);
- void time_fx_motion (GtkCanvasItem*, GdkEvent*);
- void start_time_fx (GtkCanvasItem*, GdkEvent*);
- void end_time_fx (GtkCanvasItem*, GdkEvent*);
+ void time_fx_motion (GnomeCanvasItem*, GdkEvent*);
+ void start_time_fx (GnomeCanvasItem*, GdkEvent*);
+ void end_time_fx (GnomeCanvasItem*, GdkEvent*);
struct TimeStretchDialog : public ArdourDialog {
ARDOUR::Session::TimeStretchRequest request;
void handle_new_imageframe_time_axis_view(std::string track_name, void* src) ;
void handle_new_imageframe_marker_time_axis_view(std::string track_name, TimeAxisView* marked_track) ;
- void start_imageframe_grab(GtkCanvasItem*, GdkEvent*) ;
- void start_markerview_grab(GtkCanvasItem*, GdkEvent*) ;
-
- void imageframe_drag_motion_callback(GtkCanvasItem*, GdkEvent*) ;
- void markerview_drag_motion_callback(GtkCanvasItem*, GdkEvent*) ;
- void timeaxis_item_drag_finished_callback(GtkCanvasItem*, GdkEvent*) ;
-
- gint canvas_imageframe_item_view_event(GtkCanvasItem* item, GdkEvent* event, ImageFrameView* ifv);
- gint canvas_imageframe_view_event(GtkCanvasItem* item, GdkEvent* event, ImageFrameTimeAxis* ifta);
- gint canvas_imageframe_start_handle_event(GtkCanvasItem* item, GdkEvent* event, ImageFrameView* ifv);
- gint canvas_imageframe_end_handle_event(GtkCanvasItem* item, GdkEvent* event, ImageFrameView* ifv);
-
- gint canvas_marker_time_axis_view_event(GtkCanvasItem* item, GdkEvent* event, MarkerTimeAxis* mta);
- gint canvas_markerview_item_view_event(GtkCanvasItem* item, GdkEvent* event, MarkerView* mv);
- gint canvas_markerview_start_handle_event(GtkCanvasItem* item, GdkEvent* event, MarkerView* mv);
- gint canvas_markerview_end_handle_event(GtkCanvasItem* item, GdkEvent* event, MarkerView* mv);
-
- void imageframe_start_handle_op(GtkCanvasItem* item, GdkEvent* event) ;
- void imageframe_end_handle_op(GtkCanvasItem* item, GdkEvent* event) ;
- void imageframe_start_handle_trim_motion(GtkCanvasItem* item, GdkEvent* event) ;
- void imageframe_start_handle_end_trim(GtkCanvasItem* item, GdkEvent* event) ;
- void imageframe_end_handle_trim_motion(GtkCanvasItem* item, GdkEvent* event) ;
- void imageframe_end_handle_end_trim(GtkCanvasItem* item, GdkEvent* event) ;
+ void start_imageframe_grab(GnomeCanvasItem*, GdkEvent*) ;
+ void start_markerview_grab(GnomeCanvasItem*, GdkEvent*) ;
+
+ void imageframe_drag_motion_callback(GnomeCanvasItem*, GdkEvent*) ;
+ void markerview_drag_motion_callback(GnomeCanvasItem*, GdkEvent*) ;
+ void timeaxis_item_drag_finished_callback(GnomeCanvasItem*, GdkEvent*) ;
+
+ gint canvas_imageframe_item_view_event(GnomeCanvasItem* item, GdkEvent* event, ImageFrameView* ifv);
+ gint canvas_imageframe_view_event(GnomeCanvasItem* item, GdkEvent* event, ImageFrameTimeAxis* ifta);
+ gint canvas_imageframe_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, ImageFrameView* ifv);
+ gint canvas_imageframe_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, ImageFrameView* ifv);
+
+ gint canvas_marker_time_axis_view_event(GnomeCanvasItem* item, GdkEvent* event, MarkerTimeAxis* mta);
+ gint canvas_markerview_item_view_event(GnomeCanvasItem* item, GdkEvent* event, MarkerView* mv);
+ gint canvas_markerview_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, MarkerView* mv);
+ gint canvas_markerview_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, MarkerView* mv);
+
+ void imageframe_start_handle_op(GnomeCanvasItem* item, GdkEvent* event) ;
+ void imageframe_end_handle_op(GnomeCanvasItem* item, GdkEvent* event) ;
+ void imageframe_start_handle_trim_motion(GnomeCanvasItem* item, GdkEvent* event) ;
+ void imageframe_start_handle_end_trim(GnomeCanvasItem* item, GdkEvent* event) ;
+ void imageframe_end_handle_trim_motion(GnomeCanvasItem* item, GdkEvent* event) ;
+ void imageframe_end_handle_end_trim(GnomeCanvasItem* item, GdkEvent* event) ;
- void markerview_item_start_handle_op(GtkCanvasItem* item, GdkEvent* event) ;
- void markerview_item_end_handle_op(GtkCanvasItem* item, GdkEvent* event) ;
- void markerview_start_handle_trim_motion(GtkCanvasItem* item, GdkEvent* event) ;
- void markerview_start_handle_end_trim(GtkCanvasItem* item, GdkEvent* event) ;
- void markerview_end_handle_trim_motion(GtkCanvasItem* item, GdkEvent* event) ;
- void markerview_end_handle_end_trim(GtkCanvasItem* item, GdkEvent* event) ;
-
- void popup_imageframe_edit_menu(int button, int32_t time, GtkCanvasItem* ifv, bool with_frame) ;
- void popup_marker_time_axis_edit_menu(int button, int32_t time, GtkCanvasItem* ifv, bool with_frame) ;
+ void markerview_item_start_handle_op(GnomeCanvasItem* item, GdkEvent* event) ;
+ void markerview_item_end_handle_op(GnomeCanvasItem* item, GdkEvent* event) ;
+ void markerview_start_handle_trim_motion(GnomeCanvasItem* item, GdkEvent* event) ;
+ void markerview_start_handle_end_trim(GnomeCanvasItem* item, GdkEvent* event) ;
+ void markerview_end_handle_trim_motion(GnomeCanvasItem* item, GdkEvent* event) ;
+ void markerview_end_handle_end_trim(GnomeCanvasItem* item, GdkEvent* event) ;
+
+ void popup_imageframe_edit_menu(int button, int32_t time, GnomeCanvasItem* ifv, bool with_frame) ;
+ void popup_marker_time_axis_edit_menu(int button, int32_t time, GnomeCanvasItem* ifv, bool with_frame) ;
ImageFrameSocketHandler* image_socket_listener ;
/* </CMT Additions> */
#include <cstdlib>
#include <cmath>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <ardour/diskstream.h>
#include <ardour/audioplaylist.h>
using namespace Gtk;
gint
-Editor::_canvas_copy_region_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_copy_region_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
Editor* editor = (Editor*)data;
return editor->canvas_copy_region_event (item, event);
}
gint
-Editor::_canvas_crossfade_view_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_crossfade_view_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
CrossfadeView* xfv = static_cast<CrossfadeView*> (data);
Editor* editor = dynamic_cast<Editor*>(&xfv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_fade_in_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_fade_in_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
AudioRegionView* rv = static_cast<AudioRegionView*> (data);
Editor* editor = dynamic_cast<Editor*>(&rv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_fade_in_handle_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_fade_in_handle_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
AudioRegionView* rv = static_cast<AudioRegionView*> (data);
Editor* editor = dynamic_cast<Editor*>(&rv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_fade_out_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_fade_out_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
AudioRegionView* rv = static_cast<AudioRegionView*> (data);
Editor* editor = dynamic_cast<Editor*>(&rv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_fade_out_handle_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_fade_out_handle_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
AudioRegionView* rv = static_cast<AudioRegionView*> (data);
Editor* editor = dynamic_cast<Editor*>(&rv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_region_view_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_region_view_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
AudioRegionView *rv = reinterpret_cast<AudioRegionView *>(data);
Editor* editor = dynamic_cast<Editor*>(&rv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_region_view_name_highlight_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_region_view_name_highlight_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
AudioRegionView *rv = reinterpret_cast<AudioRegionView *> (data);
Editor* editor = dynamic_cast<Editor*>(&rv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_region_view_name_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_region_view_name_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
AudioRegionView *rv = reinterpret_cast<AudioRegionView *> (data);
Editor* editor = dynamic_cast<Editor*>(&rv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_stream_view_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_stream_view_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
/* note that stream views are by definition audio track views */
}
gint
-Editor::_canvas_automation_track_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_automation_track_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
AutomationTimeAxisView* atv = (AutomationTimeAxisView*) data;
Editor* editor = dynamic_cast<Editor*>(&atv->editor);
}
gint
-Editor::_canvas_control_point_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_control_point_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
ControlPoint *cp = reinterpret_cast<ControlPoint *>(data);
Editor* editor = dynamic_cast<Editor*>(&cp->line.trackview.editor);
}
gint
-Editor::_canvas_line_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_line_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
AutomationLine *line = reinterpret_cast<AutomationLine*> (data);
Editor* editor = dynamic_cast<Editor*>(&line->trackview.editor);
}
gint
-Editor::_canvas_tempo_marker_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_tempo_marker_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
Editor* editor = dynamic_cast<Editor*>((PublicEditor*) data);
return editor->canvas_tempo_marker_event (item, event);
}
gint
-Editor::_canvas_meter_marker_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_meter_marker_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
Editor* editor = dynamic_cast<Editor*>((PublicEditor *) data);
return editor->canvas_meter_marker_event (item, event);
}
gint
-Editor::_canvas_tempo_bar_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_tempo_bar_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
/* XXX NO CAST */
Editor* editor = (Editor*) data;
}
gint
-Editor::_canvas_meter_bar_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_meter_bar_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
/* XXX NO CAST */
Editor* editor = (Editor*) data;
}
gint
-Editor::_canvas_marker_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_marker_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
Editor* editor = dynamic_cast<Editor*>((PublicEditor*) data);
return editor->canvas_marker_event (item, event);
}
gint
-Editor::_canvas_marker_bar_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_marker_bar_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
/* NO CAST */
Editor* editor = (Editor*) data;
}
gint
-Editor::_canvas_range_marker_bar_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_range_marker_bar_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
/* NO CAST */
Editor* editor = (Editor*) data;
}
gint
-Editor::_canvas_transport_marker_bar_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_transport_marker_bar_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
/* NO CAST */
Editor* editor = (Editor*) data;
}
gint
-Editor::_canvas_playhead_cursor_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_playhead_cursor_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
/* NO CAST */
Editor* editor = (Editor*) data;
}
gint
-Editor::_canvas_edit_cursor_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_edit_cursor_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
/* NO CAST */
Editor* editor = (Editor*) data;
}
gint
-Editor::_canvas_zoom_rect_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_zoom_rect_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
Editor* editor = dynamic_cast<Editor*>((PublicEditor*) data);
return editor->canvas_zoom_rect_event (item, event);
}
gint
-Editor::_canvas_selection_rect_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_selection_rect_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
Editor* editor = dynamic_cast<Editor*>((PublicEditor*) data);
return editor->canvas_selection_rect_event (item, event);
}
gint
-Editor::_canvas_selection_start_trim_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_selection_start_trim_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
Editor* editor = dynamic_cast<Editor*>((PublicEditor*) data);
return editor->canvas_selection_start_trim_event (item, event);
}
gint
-Editor::_canvas_selection_end_trim_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_selection_end_trim_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
Editor* editor = dynamic_cast<Editor*>((PublicEditor*) data);
return editor->canvas_selection_end_trim_event (item, event);
}
gint
-Editor::_track_canvas_event (GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_track_canvas_event (GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
/* NO CAST */
/********** END OF.TATIC EVENT HANDLERS */
gint
-Editor::track_canvas_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::track_canvas_event (GnomeCanvasItem *item, GdkEvent *event)
{
gint x, y;
}
gint
-Editor::track_canvas_motion (GtkCanvasItem *item, GdkEvent *ev)
+Editor::track_canvas_motion (GnomeCanvasItem *item, GdkEvent *ev)
{
if (verbose_cursor_visible) {
- gtk_canvas_item_set (verbose_canvas_cursor,
+ gnome_canvas_item_set (verbose_canvas_cursor,
"x", ev->motion.x + 20,
"y", ev->motion.y + 20,
NULL);
}
gint
-Editor::typed_event (GtkCanvasItem *item, GdkEvent *event, ItemType type)
+Editor::typed_event (GnomeCanvasItem *item, GdkEvent *event, ItemType type)
{
gint ret = FALSE;
}
gint
-Editor::canvas_region_view_event (GtkCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
+Editor::canvas_region_view_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
{
gint ret = FALSE;
}
gint
-Editor::canvas_stream_view_event (GtkCanvasItem *item, GdkEvent *event, AudioTimeAxisView *tv)
+Editor::canvas_stream_view_event (GnomeCanvasItem *item, GdkEvent *event, AudioTimeAxisView *tv)
{
gint ret = FALSE;
gint
-Editor::canvas_automation_track_event (GtkCanvasItem *item, GdkEvent *event, AutomationTimeAxisView *atv)
+Editor::canvas_automation_track_event (GnomeCanvasItem *item, GdkEvent *event, AutomationTimeAxisView *atv)
{
gint ret = FALSE;
}
gint
-Editor::canvas_fade_in_event (GtkCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
+Editor::canvas_fade_in_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
{
/* we handle only button 3 press/release events */
}
gint
-Editor::canvas_fade_in_handle_event (GtkCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
+Editor::canvas_fade_in_handle_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
{
gint ret = FALSE;
}
gint
-Editor::canvas_fade_out_event (GtkCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
+Editor::canvas_fade_out_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
{
/* we handle only button 3 press/release events */
}
gint
-Editor::canvas_fade_out_handle_event (GtkCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
+Editor::canvas_fade_out_handle_event (GnomeCanvasItem *item, GdkEvent *event, AudioRegionView *rv)
{
gint ret = FALSE;
};
gint
-Editor::canvas_crossfade_view_event (GtkCanvasItem* item, GdkEvent* event, CrossfadeView* xfv)
+Editor::canvas_crossfade_view_event (GnomeCanvasItem* item, GdkEvent* event, CrossfadeView* xfv)
{
/* we handle only button 3 press/release events */
}
gint
-Editor::canvas_control_point_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_control_point_event (GnomeCanvasItem *item, GdkEvent *event)
{
ItemType type;
ControlPoint *cp;
}
gint
-Editor::canvas_line_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_line_event (GnomeCanvasItem *item, GdkEvent *event)
{
ItemType type;
AutomationLine *al;
gint
-Editor::canvas_selection_rect_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_selection_rect_event (GnomeCanvasItem *item, GdkEvent *event)
{
gint ret = FALSE;
SelectionRect *rect = 0;
}
gint
-Editor::canvas_selection_start_trim_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_selection_start_trim_event (GnomeCanvasItem *item, GdkEvent *event)
{
gint ret = FALSE;
SelectionRect *rect = 0;
}
gint
-Editor::canvas_selection_end_trim_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_selection_end_trim_event (GnomeCanvasItem *item, GdkEvent *event)
{
gint ret = FALSE;
SelectionRect *rect = 0;
gint
-Editor::canvas_region_view_name_highlight_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_region_view_name_highlight_event (GnomeCanvasItem *item, GdkEvent *event)
{
gint ret = FALSE;
}
gint
-Editor::canvas_region_view_name_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_region_view_name_event (GnomeCanvasItem *item, GdkEvent *event)
{
gint ret = FALSE;
}
gint
-Editor::canvas_marker_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_marker_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, MarkerItem);
}
gint
-Editor::canvas_marker_bar_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_marker_bar_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, MarkerBarItem);
}
gint
-Editor::canvas_range_marker_bar_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_range_marker_bar_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, RangeMarkerBarItem);
}
gint
-Editor::canvas_transport_marker_bar_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_transport_marker_bar_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, TransportMarkerBarItem);
}
gint
-Editor::canvas_tempo_marker_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_tempo_marker_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, TempoMarkerItem);
}
gint
-Editor::canvas_meter_marker_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_meter_marker_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, MeterMarkerItem);
}
gint
-Editor::canvas_tempo_bar_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_tempo_bar_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, TempoBarItem);
}
gint
-Editor::canvas_meter_bar_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_meter_bar_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, MeterBarItem);
}
gint
-Editor::canvas_playhead_cursor_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_playhead_cursor_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, PlayheadCursorItem);
}
gint
-Editor::canvas_edit_cursor_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_edit_cursor_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, EditCursorItem);
}
gint
-Editor::canvas_zoom_rect_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_zoom_rect_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, NoItem);
}
gint
-Editor::canvas_copy_region_event (GtkCanvasItem *item, GdkEvent *event)
+Editor::canvas_copy_region_event (GnomeCanvasItem *item, GdkEvent *event)
{
return typed_event (item, event, RegionItem);
}
#include <cstdlib>
#include <cmath>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include "utils.h"
#include "editor.h"
Editor::Cursor::Cursor (Editor& ed, const string& color, GtkSignalFunc callbck)
: editor (ed), callback (callbck), length(1.0)
{
- GtkCanvasGroup *group;
- points = gtk_canvas_points_new (2);
+ GnomeCanvasGroup *group;
+ points = gnome_canvas_points_new (2);
/* "randomly" initialize coords */
points->coords[2] = 1.0;
points->coords[3] = 0.0;
- group = GTK_CANVAS_GROUP (editor.cursor_group);
+ group = GNOME_CANVAS_GROUP (editor.cursor_group);
// cerr << "set cursor points, nc = " << points->num_points << endl;
- canvas_item = gtk_canvas_item_new (group,
- gtk_canvas_line_get_type(),
+ canvas_item = gnome_canvas_item_new (group,
+ gnome_canvas_line_get_type(),
"points", points,
"fill_color", color.c_str(),
"width_pixels", 1,
{
gtk_object_destroy (GTK_OBJECT(canvas_item));
- gtk_canvas_points_unref (points);
+ gnome_canvas_points_unref (points);
}
void
double new_pos = editor.frame_to_unit (frame);
if (editor.session == 0) {
- gtk_canvas_item_hide (canvas_item);
+ gnome_canvas_item_hide (canvas_item);
} else {
- gtk_canvas_item_show (canvas_item);
+ gnome_canvas_item_show (canvas_item);
}
current_frame = frame;
/* change in position is not visible, so just raise it */
- gtk_canvas_item_raise_to_top (canvas_item);
+ gnome_canvas_item_raise_to_top (canvas_item);
return;
}
points->coords[2] = new_pos;
// cerr << "set cursor2 al points, nc = " << points->num_points << endl;
- gtk_canvas_item_set (canvas_item, "points", points, NULL);
- gtk_canvas_item_raise_to_top (canvas_item);
+ gnome_canvas_item_set (canvas_item, "points", points, NULL);
+ gnome_canvas_item_raise_to_top (canvas_item);
}
void
length = units;
points->coords[3] = points->coords[1] + length;
// cerr << "set cursor3 al points, nc = " << points->num_points << endl;
- gtk_canvas_item_set (canvas_item, "points", points, NULL);
+ gnome_canvas_item_set (canvas_item, "points", points, NULL);
}
void
points->coords[1] = position;
points->coords[3] = position + length;
// cerr << "set cursor4 al points, nc = " << points->num_points << endl;
- gtk_canvas_item_set (canvas_item, "points", points, NULL);
+ gnome_canvas_item_set (canvas_item, "points", points, NULL);
}
}
void
-Editor::popup_imageframe_edit_menu(int button, int32_t time, GtkCanvasItem* ifv, bool with_item)
+Editor::popup_imageframe_edit_menu(int button, int32_t time, GnomeCanvasItem* ifv, bool with_item)
{
ImageFrameTimeAxis* ifta = dynamic_cast<ImageFrameTimeAxis*>(clicked_trackview) ;
}
void
-Editor::popup_marker_time_axis_edit_menu(int button, int32_t time, GtkCanvasItem* ifv, bool with_item)
+Editor::popup_marker_time_axis_edit_menu(int button, int32_t time, GnomeCanvasItem* ifv, bool with_item)
{
MarkerTimeAxis* mta = dynamic_cast<MarkerTimeAxis*>(clicked_trackview) ;
/**
* ---------------------------------------------------------------------------------------------------
* Static event handlers
- * These handlers deal with events from the GtkCanvas, a c-based component
+ * These handlers deal with events from the GnomeCanvas, a c-based component
*/
gint
-Editor::_canvas_imageframe_start_handle_event(GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_imageframe_start_handle_event(GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
ImageFrameView* ifv = (ImageFrameView*) data ;
Editor* editor = dynamic_cast<Editor*> (&ifv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_imageframe_end_handle_event(GtkCanvasItem *item, GdkEvent *event, gpointer data)
+Editor::_canvas_imageframe_end_handle_event(GnomeCanvasItem *item, GdkEvent *event, gpointer data)
{
ImageFrameView* ifv = (ImageFrameView*) data ;
Editor* editor = dynamic_cast<Editor*> (&ifv->get_time_axis_view().editor);
gint
-Editor::_canvas_imageframe_item_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data)
+Editor::_canvas_imageframe_item_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data)
{
ImageFrameView *ifv = (ImageFrameView *) data ;
Editor* editor = dynamic_cast<Editor*> (&ifv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_imageframe_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data)
+Editor::_canvas_imageframe_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data)
{
ImageFrameTimeAxis *ifta = (ImageFrameTimeAxis*) data ;
Editor* editor = dynamic_cast<Editor*> (&ifta->editor);
}
gint
-Editor::_canvas_marker_time_axis_view_event(GtkCanvasItem* item, GdkEvent* event, gpointer data)
+Editor::_canvas_marker_time_axis_view_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data)
{
MarkerTimeAxis* mta = (MarkerTimeAxis*)data ;
Editor* editor = dynamic_cast<Editor*> (&mta->editor);
}
gint
-Editor::_canvas_markerview_item_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data)
+Editor::_canvas_markerview_item_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data)
{
MarkerView* mv = (MarkerView*) data ;
Editor* editor = dynamic_cast<Editor*> (&mv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_markerview_start_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data)
+Editor::_canvas_markerview_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data)
{
MarkerView* mv = (MarkerView*)data ;
Editor* editor = dynamic_cast<Editor*> (&mv->get_time_axis_view().editor);
}
gint
-Editor::_canvas_markerview_end_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data)
+Editor::_canvas_markerview_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data)
{
MarkerView* mv = (MarkerView*)data ;
Editor* editor = dynamic_cast<Editor*> (&mv->get_time_axis_view().editor);
*/
gint
-Editor::canvas_imageframe_item_view_event(GtkCanvasItem *item, GdkEvent *event, ImageFrameView *ifv)
+Editor::canvas_imageframe_item_view_event(GnomeCanvasItem *item, GdkEvent *event, ImageFrameView *ifv)
{
gint ret = FALSE ;
ImageFrameTimeAxisGroup* iftag = 0 ;
}
gint
-Editor::canvas_imageframe_start_handle_event(GtkCanvasItem *item, GdkEvent *event, ImageFrameView *ifv)
+Editor::canvas_imageframe_start_handle_event(GnomeCanvasItem *item, GdkEvent *event, ImageFrameView *ifv)
{
gint ret = FALSE ;
ImageFrameTimeAxisGroup* iftag = 0 ;
}
gint
-Editor::canvas_imageframe_end_handle_event(GtkCanvasItem *item, GdkEvent *event, ImageFrameView *ifv)
+Editor::canvas_imageframe_end_handle_event(GnomeCanvasItem *item, GdkEvent *event, ImageFrameView *ifv)
{
gint ret = FALSE ;
ImageFrameTimeAxisGroup* iftag = 0 ;
}
gint
-Editor::canvas_imageframe_view_event(GtkCanvasItem* item, GdkEvent* event, ImageFrameTimeAxis* ifta)
+Editor::canvas_imageframe_view_event(GnomeCanvasItem* item, GdkEvent* event, ImageFrameTimeAxis* ifta)
{
gint ret = FALSE ;
switch (event->type)
}
gint
-Editor::canvas_marker_time_axis_view_event(GtkCanvasItem *item, GdkEvent* event, MarkerTimeAxis* mta)
+Editor::canvas_marker_time_axis_view_event(GnomeCanvasItem *item, GdkEvent* event, MarkerTimeAxis* mta)
{
gint ret = FALSE ;
switch (event->type)
gint
-Editor::canvas_markerview_item_view_event(GtkCanvasItem *item, GdkEvent* event, MarkerView* mta)
+Editor::canvas_markerview_item_view_event(GnomeCanvasItem *item, GdkEvent* event, MarkerView* mta)
{
gint ret = FALSE ;
switch (event->type)
}
gint
-Editor::canvas_markerview_start_handle_event(GtkCanvasItem* item, GdkEvent* event, MarkerView* mta)
+Editor::canvas_markerview_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, MarkerView* mta)
{
gint ret = FALSE ;
switch (event->type)
}
gint
-Editor::canvas_markerview_end_handle_event(GtkCanvasItem* item, GdkEvent* event, MarkerView* mta)
+Editor::canvas_markerview_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, MarkerView* mta)
{
gint ret = FALSE ;
switch (event->type)
/* <CMT Additions file="editor_mouse.cc"> */
void
-Editor::start_imageframe_grab(GtkCanvasItem* item, GdkEvent* event)
+Editor::start_imageframe_grab(GnomeCanvasItem* item, GdkEvent* event)
{
ImageFrameView* ifv = ((ImageFrameTimeAxis*)clicked_trackview)->get_view()->get_selected_imageframe_view() ;
drag_info.copy = false ;
so move them to the top afterwards.
*/
- gtk_canvas_item_raise_to_top(drag_info.item) ;
- gtk_canvas_item_raise_to_top(drag_info.last_trackview->canvas_display) ;
- //gtk_canvas_item_raise_to_top(time_line_group) ;
- gtk_canvas_item_raise_to_top (cursor_group);
+ gnome_canvas_item_raise_to_top(drag_info.item) ;
+ gnome_canvas_item_raise_to_top(drag_info.last_trackview->canvas_display) ;
+ //gnome_canvas_item_raise_to_top(time_line_group) ;
+ gnome_canvas_item_raise_to_top (cursor_group);
start_grab(event) ;
void
-Editor::start_markerview_grab(GtkCanvasItem* item, GdkEvent* event)
+Editor::start_markerview_grab(GnomeCanvasItem* item, GdkEvent* event)
{
MarkerView* mv = ((MarkerTimeAxis*)clicked_trackview)->get_view()->get_selected_time_axis_item() ;
drag_info.copy = false ;
so move them to the top afterwards.
*/
- gtk_canvas_item_raise_to_top(drag_info.item) ;
- gtk_canvas_item_raise_to_top(drag_info.last_trackview->canvas_display) ;
- //gtk_canvas_item_raise_to_top(time_line_group) ;
- gtk_canvas_item_raise_to_top (cursor_group);
+ gnome_canvas_item_raise_to_top(drag_info.item) ;
+ gnome_canvas_item_raise_to_top(drag_info.last_trackview->canvas_display) ;
+ //gnome_canvas_item_raise_to_top(time_line_group) ;
+ gnome_canvas_item_raise_to_top (cursor_group);
start_grab(event) ;
void
-Editor::markerview_drag_motion_callback(GtkCanvasItem*, GdkEvent* event)
+Editor::markerview_drag_motion_callback(GnomeCanvasItem*, GdkEvent* event)
{
double cx, cy ;
}
void
-Editor::imageframe_drag_motion_callback(GtkCanvasItem*, GdkEvent* event)
+Editor::imageframe_drag_motion_callback(GnomeCanvasItem*, GdkEvent* event)
{
double cx, cy ;
}
void
-Editor::timeaxis_item_drag_finished_callback(GtkCanvasItem*, GdkEvent* event)
+Editor::timeaxis_item_drag_finished_callback(GnomeCanvasItem*, GdkEvent* event)
{
jack_nframes_t where ;
TimeAxisViewItem* tavi = reinterpret_cast<TimeAxisViewItem*>(drag_info.data) ;
void
-Editor::imageframe_start_handle_op(GtkCanvasItem* item, GdkEvent* event)
+Editor::imageframe_start_handle_op(GnomeCanvasItem* item, GdkEvent* event)
{
// get the selected item from the parent time axis
ImageFrameTimeAxis* ifta = dynamic_cast<ImageFrameTimeAxis*>(clicked_trackview) ;
}
void
-Editor::imageframe_end_handle_op(GtkCanvasItem* item, GdkEvent* event)
+Editor::imageframe_end_handle_op(GnomeCanvasItem* item, GdkEvent* event)
{
// get the selected item from the parent time axis
ImageFrameTimeAxis* ifta = dynamic_cast<ImageFrameTimeAxis*>(clicked_trackview) ;
}
void
-Editor::imageframe_start_handle_trim_motion(GtkCanvasItem* item, GdkEvent* event)
+Editor::imageframe_start_handle_trim_motion(GnomeCanvasItem* item, GdkEvent* event)
{
ImageFrameView* ifv = reinterpret_cast<ImageFrameView*> (drag_info.data) ;
}
void
-Editor::imageframe_start_handle_end_trim(GtkCanvasItem* item, GdkEvent* event)
+Editor::imageframe_start_handle_end_trim(GnomeCanvasItem* item, GdkEvent* event)
{
ImageFrameView* ifv = reinterpret_cast<ImageFrameView *> (drag_info.data) ;
}
void
-Editor::imageframe_end_handle_trim_motion(GtkCanvasItem* item, GdkEvent* event)
+Editor::imageframe_end_handle_trim_motion(GnomeCanvasItem* item, GdkEvent* event)
{
ImageFrameView* ifv = reinterpret_cast<ImageFrameView *> (drag_info.data) ;
void
-Editor::imageframe_end_handle_end_trim (GtkCanvasItem* item, GdkEvent* event)
+Editor::imageframe_end_handle_end_trim (GnomeCanvasItem* item, GdkEvent* event)
{
ImageFrameView* ifv = reinterpret_cast<ImageFrameView *> (drag_info.data) ;
void
-Editor::markerview_item_start_handle_op(GtkCanvasItem* item, GdkEvent* event)
+Editor::markerview_item_start_handle_op(GnomeCanvasItem* item, GdkEvent* event)
{
MarkerView* mv = reinterpret_cast<MarkerTimeAxis*>(clicked_trackview)->get_view()->get_selected_time_axis_item() ;
}
void
-Editor::markerview_item_end_handle_op(GtkCanvasItem* item, GdkEvent* event)
+Editor::markerview_item_end_handle_op(GnomeCanvasItem* item, GdkEvent* event)
{
MarkerView* mv = reinterpret_cast<MarkerTimeAxis*>(clicked_trackview)->get_view()->get_selected_time_axis_item() ;
if (mv == 0)
void
-Editor::markerview_start_handle_trim_motion(GtkCanvasItem* item, GdkEvent* event)
+Editor::markerview_start_handle_trim_motion(GnomeCanvasItem* item, GdkEvent* event)
{
MarkerView* mv = reinterpret_cast<MarkerView*> (drag_info.data) ;
}
void
-Editor::markerview_start_handle_end_trim(GtkCanvasItem* item, GdkEvent* event)
+Editor::markerview_start_handle_end_trim(GnomeCanvasItem* item, GdkEvent* event)
{
MarkerView* mv = reinterpret_cast<MarkerView*> (drag_info.data) ;
}
void
-Editor::markerview_end_handle_trim_motion(GtkCanvasItem* item, GdkEvent* event)
+Editor::markerview_end_handle_trim_motion(GnomeCanvasItem* item, GdkEvent* event)
{
MarkerView* mv = reinterpret_cast<MarkerView*> (drag_info.data) ;
void
-Editor::markerview_end_handle_end_trim (GtkCanvasItem* item, GdkEvent* event)
+Editor::markerview_end_handle_end_trim (GnomeCanvasItem* item, GdkEvent* event)
{
MarkerView* mv = reinterpret_cast<MarkerView*> (drag_info.data) ;
selection->set (entered_regionview);
}
- gtk_canvas_window_to_world (GTK_CANVAS(track_gtk_canvas), x, y, &dx, &dy);
+ gnome_canvas_window_to_world (GNOME_CANVAS(track_gnome_canvas), x, y, &dx, &dy);
ev.type = GDK_BUTTON_PRESS;
ev.button.x = dx;
#include <cstdlib>
#include <cmath>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <gtkmm2ext/gtk_ui.h>
#include <ardour/location.h>
}
if (location->is_mark()) {
- lam->start = new Marker (*this, GTK_CANVAS_GROUP(marker_group), color,
+ lam->start = new Marker (*this, GNOME_CANVAS_GROUP(marker_group), color,
location->name(), Marker::Mark, PublicEditor::canvas_marker_event, location->start());
lam->end = 0;
} else if (location->is_auto_loop()) {
// transport marker
- lam->start = new Marker (*this, GTK_CANVAS_GROUP(transport_marker_group), color,
+ lam->start = new Marker (*this, GNOME_CANVAS_GROUP(transport_marker_group), color,
location->name(), Marker::LoopStart, PublicEditor::canvas_marker_event, location->start());
- lam->end = new Marker (*this, GTK_CANVAS_GROUP(transport_marker_group), color,
+ lam->end = new Marker (*this, GNOME_CANVAS_GROUP(transport_marker_group), color,
location->name(), Marker::LoopEnd, PublicEditor::canvas_marker_event, location->end());
} else if (location->is_auto_punch()) {
// transport marker
- lam->start = new Marker (*this, GTK_CANVAS_GROUP(transport_marker_group), color,
+ lam->start = new Marker (*this, GNOME_CANVAS_GROUP(transport_marker_group), color,
location->name(), Marker::PunchIn, PublicEditor::canvas_marker_event, location->start());
- lam->end = new Marker (*this, GTK_CANVAS_GROUP(transport_marker_group), color,
+ lam->end = new Marker (*this, GNOME_CANVAS_GROUP(transport_marker_group), color,
location->name(), Marker::PunchOut, PublicEditor::canvas_marker_event, location->end());
} else {
// range marker
- lam->start = new Marker (*this, GTK_CANVAS_GROUP(range_marker_group), color,
+ lam->start = new Marker (*this, GNOME_CANVAS_GROUP(range_marker_group), color,
location->name(), Marker::Start, PublicEditor::canvas_marker_event, location->start());
- lam->end = new Marker (*this, GTK_CANVAS_GROUP(range_marker_group), color,
+ lam->end = new Marker (*this, GNOME_CANVAS_GROUP(range_marker_group), color,
location->name(), Marker::End, PublicEditor::canvas_marker_event, location->end());
}
}
void
-Editor::remove_marker (GtkCanvasItem* item, GdkEvent* event)
+Editor::remove_marker (GnomeCanvasItem* item, GdkEvent* event)
{
Marker* marker;
bool is_start;
}
void
-Editor::tm_marker_context_menu (GdkEventButton* ev, GtkCanvasItem* item)
+Editor::tm_marker_context_menu (GdkEventButton* ev, GnomeCanvasItem* item)
{
if (tm_marker_menu == 0) {
build_tm_marker_menu ();
void
-Editor::marker_context_menu (GdkEventButton* ev, GtkCanvasItem* item)
+Editor::marker_context_menu (GdkEventButton* ev, GnomeCanvasItem* item)
{
Marker * marker;
if ((marker = reinterpret_cast<Marker *> (gtk_object_get_data (GTK_OBJECT(item), "marker"))) == 0) {
void
-Editor::new_transport_marker_context_menu (GdkEventButton* ev, GtkCanvasItem* item)
+Editor::new_transport_marker_context_menu (GdkEventButton* ev, GnomeCanvasItem* item)
{
if (new_transport_marker_menu == 0) {
build_new_transport_marker_menu ();
}
void
-Editor::transport_marker_context_menu (GdkEventButton* ev, GtkCanvasItem* item)
+Editor::transport_marker_context_menu (GdkEventButton* ev, GnomeCanvasItem* item)
{
if (transport_marker_menu == 0) {
build_transport_marker_menu ();
Editor::new_transport_marker_menu_popdown (GdkEventAny *ev)
{
// hide rects
- gtk_canvas_item_hide (transport_bar_drag_rect);
- gtk_canvas_item_hide (range_marker_drag_rect);
+ gnome_canvas_item_hide (transport_bar_drag_rect);
+ gnome_canvas_item_hide (range_marker_drag_rect);
return FALSE;
}
double x1 = frame_to_pixel (tll->start());
double x2 = frame_to_pixel (tll->end());
- gtk_canvas_item_set (transport_loop_range_rect, "x1", x1, "x2", x2, NULL);
+ gnome_canvas_item_set (transport_loop_range_rect, "x1", x1, "x2", x2, NULL);
if (visibility) {
- gtk_canvas_item_show (transport_loop_range_rect);
+ gnome_canvas_item_show (transport_loop_range_rect);
}
}
else if (visibility) {
- gtk_canvas_item_hide (transport_loop_range_rect);
+ gnome_canvas_item_hide (transport_loop_range_rect);
}
}
double x1 = frame_to_pixel (tpl->start());
double x2 = frame_to_pixel (tpl->end());
- gtk_canvas_item_set (transport_punch_range_rect, "x1", x1, "x2", x2, NULL);
+ gnome_canvas_item_set (transport_punch_range_rect, "x1", x1, "x2", x2, NULL);
if (visibility) {
- gtk_canvas_item_show (transport_punch_range_rect);
+ gnome_canvas_item_show (transport_punch_range_rect);
}
}
else if (visibility) {
- gtk_canvas_item_hide (transport_punch_range_rect);
+ gnome_canvas_item_hide (transport_punch_range_rect);
}
// if (session->get_punch_in()) {
// double x = frame_to_pixel (transport_punch_location->start());
-// gtk_canvas_item_set (transport_punchin_line, "x1", x, "x2", x, NULL);
+// gnome_canvas_item_set (transport_punchin_line, "x1", x, "x2", x, NULL);
// if (visibility) {
-// gtk_canvas_item_show (transport_punchin_line);
+// gnome_canvas_item_show (transport_punchin_line);
// }
// }
// else if (visibility) {
-// gtk_canvas_item_hide (transport_punchin_line);
+// gnome_canvas_item_hide (transport_punchin_line);
// }
// if (session->get_punch_out()) {
// double x = frame_to_pixel (transport_punch_location->end());
-// gtk_canvas_item_set (transport_punchout_line, "x1", x, "x2", x, NULL);
+// gnome_canvas_item_set (transport_punchout_line, "x1", x, "x2", x, NULL);
// if (visibility) {
-// gtk_canvas_item_show (transport_punchout_line);
+// gnome_canvas_item_show (transport_punchout_line);
// }
// }
// else if (visibility) {
-// gtk_canvas_item_hide (transport_punchout_line);
+// gnome_canvas_item_hide (transport_punchout_line);
// }
}
if (_follow_playhead) {
- gtk_canvas_item_show (playhead_cursor->canvas_item);
+ gnome_canvas_item_show (playhead_cursor->canvas_item);
if (frame != last_update_frame) {
if (frame != last_update_frame) {
if (frame < leftmost_frame || frame > leftmost_frame + current_page_frames()) {
- gtk_canvas_item_hide (playhead_cursor->canvas_item);
+ gnome_canvas_item_hide (playhead_cursor->canvas_item);
} else {
playhead_cursor->set_position (frame);
}
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
- gtk_canvas_w2c_d (GTK_CANVAS(track_gtk_canvas), event->button.x, event->button.y, pcx, pcy);
+ gnome_canvas_w2c_d (GNOME_CANVAS(track_gnome_canvas), event->button.x, event->button.y, pcx, pcy);
break;
case GDK_MOTION_NOTIFY:
- gtk_canvas_w2c_d (GTK_CANVAS(track_gtk_canvas), event->motion.x, event->motion.y, pcx, pcy);
+ gnome_canvas_w2c_d (GNOME_CANVAS(track_gnome_canvas), event->motion.x, event->motion.y, pcx, pcy);
break;
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY:
- gtk_canvas_w2c_d (GTK_CANVAS(track_gtk_canvas), event->crossing.x, event->crossing.y, pcx, pcy);
+ gnome_canvas_w2c_d (GNOME_CANVAS(track_gnome_canvas), event->crossing.x, event->crossing.y, pcx, pcy);
break;
default:
warning << compose (_("Editor::event_frame() used on unhandled event type %1"), event->type) << endmsg;
}
gint
-Editor::button_press_handler (GtkCanvasItem* item, GdkEvent* event, ItemType item_type)
+Editor::button_press_handler (GnomeCanvasItem* item, GdkEvent* event, ItemType item_type)
{
jack_nframes_t where = event_frame (event, 0, 0);
if (event->type == GDK_BUTTON_PRESS) {
if (drag_info.item) {
- gtk_canvas_item_ungrab (drag_info.item, event->button.time);
+ gnome_canvas_item_ungrab (drag_info.item, event->button.time);
}
/* single mouse clicks on any of these item types operate
}
gint
-Editor::button_release_handler (GtkCanvasItem* item, GdkEvent* event, ItemType item_type)
+Editor::button_release_handler (GnomeCanvasItem* item, GdkEvent* event, ItemType item_type)
{
jack_nframes_t where = event_frame (event, 0, 0);
}
gint
-Editor::enter_handler (GtkCanvasItem* item, GdkEvent* event, ItemType item_type)
+Editor::enter_handler (GnomeCanvasItem* item, GdkEvent* event, ItemType item_type)
{
ControlPoint* cp;
Marker * marker;
double at_x, at_y;
at_x = cp->get_x();
at_y = cp->get_y ();
- gtk_canvas_item_i2w (cp->item, &at_x, &at_y);
+ gnome_canvas_item_i2w (cp->item, &at_x, &at_y);
at_x += 20.0;
at_y += 20.0;
double at_x, at_y;
at_x = cp->get_x();
at_y = cp->get_y ();
- gtk_canvas_item_i2w (cp->item, &at_x, &at_y);
+ gnome_canvas_item_i2w (cp->item, &at_x, &at_y);
at_x += 20.0;
at_y += 20.0;
case GainLineItem:
if (mouse_mode == MouseGain) {
- gtk_canvas_item_set (item, "fill_color_rgba", color_map[cEnteredGainLine], NULL);
+ gnome_canvas_item_set (item, "fill_color_rgba", color_map[cEnteredGainLine], NULL);
if (is_drawable()) {
gdk_window_set_cursor (track_canvas_scroller.get_window(), fader_cursor);
}
case GainAutomationLineItem:
case RedirectAutomationLineItem:
case PanAutomationLineItem:
- gtk_canvas_item_set (item, "fill_color_rgba", color_map[cEnteredAutomationLine], NULL);
+ gnome_canvas_item_set (item, "fill_color_rgba", color_map[cEnteredAutomationLine], NULL);
if (is_drawable()) {
gdk_window_set_cursor (track_canvas_scroller.get_window(), fader_cursor);
}
case FadeInHandleItem:
case FadeOutHandleItem:
if (mouse_mode == MouseObject) {
- gtk_canvas_item_set (item, "fill_color_rgba", 0, "outline_pixels", 1, NULL);
+ gnome_canvas_item_set (item, "fill_color_rgba", 0, "outline_pixels", 1, NULL);
}
break;
}
gint
-Editor::leave_handler (GtkCanvasItem* item, GdkEvent* event, ItemType item_type)
+Editor::leave_handler (GnomeCanvasItem* item, GdkEvent* event, ItemType item_type)
{
AutomationLine* al;
ControlPoint* cp;
case RedirectAutomationLineItem:
case PanAutomationLineItem:
al = reinterpret_cast<AutomationLine*> (gtk_object_get_data (GTK_OBJECT(item),"line"));
- gtk_canvas_item_set (item, "fill_color_rgba", al->get_line_color(), NULL);
+ gnome_canvas_item_set (item, "fill_color_rgba", al->get_line_color(), NULL);
if (is_drawable()) {
gdk_window_set_cursor (track_canvas_scroller.get_window(), current_canvas_cursor);
}
case FadeInHandleItem:
case FadeOutHandleItem:
rv = static_cast<AudioRegionView*>(gtk_object_get_data (GTK_OBJECT(item), "regionview"));
- gtk_canvas_item_set (item, "fill_color_rgba", rv->get_fill_color(), "outline_pixels", 0, NULL);
+ gnome_canvas_item_set (item, "fill_color_rgba", rv->get_fill_color(), "outline_pixels", 0, NULL);
break;
case AutomationTrackItem:
}
gint
-Editor::motion_handler (GtkCanvasItem* item, GdkEvent* event, ItemType item_type)
+Editor::motion_handler (GnomeCanvasItem* item, GdkEvent* event, ItemType item_type)
{
gint x, y;
drag_info.brushing = false;
drag_info.copied_location = 0;
- gtk_canvas_item_grab (drag_info.item,
+ gnome_canvas_item_grab (drag_info.item,
Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK,
cursor,
event->button.time);
}
bool
-Editor::end_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::end_grab (GnomeCanvasItem* item, GdkEvent* event)
{
bool did_drag = false;
return false;
}
- gtk_canvas_item_ungrab (drag_info.item, event->button.time);
+ gnome_canvas_item_ungrab (drag_info.item, event->button.time);
if (drag_info.finished_callback) {
(this->*(drag_info.finished_callback)) (item, event);
}
void
-Editor::start_fade_in_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_fade_in_grab (GnomeCanvasItem* item, GdkEvent* event)
{
drag_info.item = item;
drag_info.motion_callback = &Editor::fade_in_drag_motion_callback;
}
void
-Editor::fade_in_drag_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::fade_in_drag_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
jack_nframes_t pos;
}
void
-Editor::fade_in_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::fade_in_drag_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
if (drag_info.first_move) return;
}
void
-Editor::start_fade_out_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_fade_out_grab (GnomeCanvasItem* item, GdkEvent* event)
{
drag_info.item = item;
drag_info.motion_callback = &Editor::fade_out_drag_motion_callback;
}
void
-Editor::fade_out_drag_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::fade_out_drag_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
AudioRegionView* arv = static_cast<AudioRegionView*>(drag_info.data);
jack_nframes_t pos;
}
void
-Editor::fade_out_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::fade_out_drag_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
if (drag_info.first_move) return;
}
void
-Editor::start_cursor_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_cursor_grab (GnomeCanvasItem* item, GdkEvent* event)
{
drag_info.item = item;
drag_info.motion_callback = &Editor::cursor_drag_motion_callback;
}
void
-Editor::cursor_drag_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::cursor_drag_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
Cursor* cursor = (Cursor *) drag_info.data;
jack_nframes_t adjusted_frame;
}
void
-Editor::cursor_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::cursor_drag_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
if (drag_info.first_move) return;
if (location->is_mark()) {
marker_drag_line_points->coords[0] = x1;
marker_drag_line_points->coords[2] = x1;
- gtk_canvas_item_set (marker_drag_line, "points", marker_drag_line_points, NULL);
+ gnome_canvas_item_set (marker_drag_line, "points", marker_drag_line_points, NULL);
}
else {
- gtk_canvas_item_set (range_marker_drag_rect, "x1", x1, "x2", x2, NULL);
+ gnome_canvas_item_set (range_marker_drag_rect, "x1", x1, "x2", x2, NULL);
}
}
void
-Editor::start_marker_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_marker_grab (GnomeCanvasItem* item, GdkEvent* event)
{
Marker* marker;
update_marker_drag_item (location);
if (location->is_mark()) {
- gtk_canvas_item_show (marker_drag_line);
- gtk_canvas_item_raise_to_top (marker_drag_line);
+ gnome_canvas_item_show (marker_drag_line);
+ gnome_canvas_item_raise_to_top (marker_drag_line);
}
else {
- gtk_canvas_item_show (range_marker_drag_rect);
- gtk_canvas_item_raise_to_top (range_marker_drag_rect);
+ gnome_canvas_item_show (range_marker_drag_rect);
+ gnome_canvas_item_raise_to_top (range_marker_drag_rect);
}
if (is_start) show_verbose_time_cursor (location->start(), 10);
}
void
-Editor::marker_drag_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::marker_drag_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
jack_nframes_t f_delta;
Marker* marker = (Marker *) drag_info.data;
}
void
-Editor::marker_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::marker_drag_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
if (drag_info.first_move) {
marker_drag_motion_callback (item, event);
location->set (drag_info.copied_location->start(), drag_info.copied_location->end());
}
- gtk_canvas_item_hide (marker_drag_line);
- gtk_canvas_item_hide (range_marker_drag_rect);
+ gnome_canvas_item_hide (marker_drag_line);
+ gnome_canvas_item_hide (range_marker_drag_rect);
}
void
-Editor::start_meter_marker_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_meter_marker_grab (GnomeCanvasItem* item, GdkEvent* event)
{
Marker* marker;
MeterMarker* meter_marker;
}
void
-Editor::meter_marker_drag_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::meter_marker_drag_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
MeterMarker* marker = (MeterMarker *) drag_info.data;
jack_nframes_t adjusted_frame;
}
void
-Editor::meter_marker_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::meter_marker_drag_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
if (drag_info.first_move) return;
}
void
-Editor::start_tempo_marker_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_tempo_marker_grab (GnomeCanvasItem* item, GdkEvent* event)
{
Marker* marker;
TempoMarker* tempo_marker;
}
void
-Editor::tempo_marker_drag_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::tempo_marker_drag_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
TempoMarker* marker = (TempoMarker *) drag_info.data;
jack_nframes_t adjusted_frame;
}
void
-Editor::tempo_marker_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::tempo_marker_drag_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
if (drag_info.first_move) return;
}
void
-Editor::remove_gain_control_point (GtkCanvasItem*item, GdkEvent* event)
+Editor::remove_gain_control_point (GnomeCanvasItem*item, GdkEvent* event)
{
ControlPoint* control_point;
}
void
-Editor::remove_control_point (GtkCanvasItem*item, GdkEvent* event)
+Editor::remove_control_point (GnomeCanvasItem*item, GdkEvent* event)
{
ControlPoint* control_point;
}
void
-Editor::start_control_point_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_control_point_grab (GnomeCanvasItem* item, GdkEvent* event)
{
ControlPoint* control_point;
}
void
-Editor::control_point_drag_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::control_point_drag_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
ControlPoint* cp = reinterpret_cast<ControlPoint *> (drag_info.data);
}
- gtk_canvas_item_w2i (cp->line.parent_group(), &cx, &cy);
+ gnome_canvas_item_w2i (cp->line.parent_group(), &cx, &cy);
cx = max (0.0, cx);
cy = max (0.0, cy);
}
void
-Editor::control_point_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::control_point_drag_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
ControlPoint* cp = reinterpret_cast<ControlPoint *> (drag_info.data);
control_point_drag_motion_callback (item, event);
}
void
-Editor::start_line_grab_from_regionview (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_line_grab_from_regionview (GnomeCanvasItem* item, GdkEvent* event)
{
switch (mouse_mode) {
case MouseGain:
}
void
-Editor::start_line_grab_from_line (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_line_grab_from_line (GnomeCanvasItem* item, GdkEvent* event)
{
AutomationLine* al;
cx = event->button.x;
cy = event->button.y;
- gtk_canvas_item_w2i (line->parent_group(), &cx, &cy);
+ gnome_canvas_item_w2i (line->parent_group(), &cx, &cy);
frame_within_region = (jack_nframes_t) floor (cx * frames_per_unit);
if (!line->control_points_adjacent (frame_within_region, current_line_drag_info.before,
}
void
-Editor::line_drag_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::line_drag_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
AutomationLine* line = reinterpret_cast<AutomationLine *> (drag_info.data);
double cx = drag_info.current_pointer_x;
double cy = drag_info.current_pointer_y;
- gtk_canvas_item_w2i (line->parent_group(), &cx, &cy);
+ gnome_canvas_item_w2i (line->parent_group(), &cx, &cy);
double fraction;
fraction = 1.0 - (cy / line->height());
}
void
-Editor::line_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::line_drag_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
AutomationLine* line = reinterpret_cast<AutomationLine *> (drag_info.data);
line_drag_motion_callback (item, event);
}
void
-Editor::start_region_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_region_grab (GnomeCanvasItem* item, GdkEvent* event)
{
if (selection->audio_regions.empty() || clicked_regionview == 0) {
return;
}
void
-Editor::start_region_copy_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_region_copy_grab (GnomeCanvasItem* item, GdkEvent* event)
{
if (selection->audio_regions.empty() || clicked_regionview == 0) {
return;
}
void
-Editor::start_region_brush_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_region_brush_grab (GnomeCanvasItem* item, GdkEvent* event)
{
if (selection->audio_regions.empty() || clicked_regionview == 0) {
return;
}
void
-Editor::region_drag_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::region_drag_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
double x_delta;
double y_delta = 0;
double ix1, ix2, iy1, iy2;
int32_t n = 0;
- gtk_canvas_item_get_bounds (rv2->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
- gtk_canvas_item_i2w (rv2->get_canvas_group(), &ix1, &iy1);
+ gnome_canvas_item_get_bounds (rv2->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
+ gnome_canvas_item_i2w (rv2->get_canvas_group(), &ix1, &iy1);
TimeAxisView* tvp2 = trackview_by_y_position (iy1);
AudioTimeAxisView* atv2 = dynamic_cast<AudioTimeAxisView*>(tvp2);
*/
double ix1, ix2, iy1, iy2;
- gtk_canvas_item_get_bounds (rv2->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
- gtk_canvas_item_i2w (rv2->get_canvas_group(), &ix1, &iy1);
+ gnome_canvas_item_get_bounds (rv2->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
+ gnome_canvas_item_i2w (rv2->get_canvas_group(), &ix1, &iy1);
if (ix1 <= 1) {
x_delta = 0;
the parent.
*/
- gtk_canvas_item_get_bounds (rv->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
- gtk_canvas_item_i2w (rv->get_canvas_group(), &ix1, &iy1);
+ gnome_canvas_item_get_bounds (rv->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
+ gnome_canvas_item_i2w (rv->get_canvas_group(), &ix1, &iy1);
TimeAxisView* tvp2 = trackview_by_y_position (iy1);
AudioTimeAxisView* canvas_atv = dynamic_cast<AudioTimeAxisView*>(tvp2);
AudioTimeAxisView* temp_atv;
on the top, since its parent is the whole canvas.
*/
- gtk_canvas_item_raise_to_top (rv->get_canvas_group());
- gtk_canvas_item_raise_to_top (rv->get_time_axis_view().canvas_display);
- gtk_canvas_item_raise_to_top (cursor_group);
+ gnome_canvas_item_raise_to_top (rv->get_canvas_group());
+ gnome_canvas_item_raise_to_top (rv->get_time_axis_view().canvas_display);
+ gnome_canvas_item_raise_to_top (cursor_group);
/* freeze the playlists from notifying till
the motion is done.
}
if (drag_info.first_move) {
- gtk_canvas_item_raise_to_top (cursor_group);
+ gnome_canvas_item_raise_to_top (cursor_group);
}
drag_info.first_move = false;
}
void
-Editor::region_drag_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::region_drag_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
jack_nframes_t where;
AudioRegionView* rv = reinterpret_cast<AudioRegionView *> (drag_info.data);
double ix1, ix2, iy1, iy2;
- gtk_canvas_item_get_bounds ((*i)->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
- gtk_canvas_item_i2w ((*i)->get_canvas_group(), &ix1, &iy1);
+ gnome_canvas_item_get_bounds ((*i)->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
+ gnome_canvas_item_i2w ((*i)->get_canvas_group(), &ix1, &iy1);
TimeAxisView* tvp2 = trackview_by_y_position (iy1);
AudioTimeAxisView* atv2 = dynamic_cast<AudioTimeAxisView*>(tvp2);
double ix1, ix2, iy1, iy2;
- gtk_canvas_item_get_bounds ((*i)->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
- gtk_canvas_item_i2w ((*i)->get_canvas_group(), &ix1, &iy1);
+ gnome_canvas_item_get_bounds ((*i)->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
+ gnome_canvas_item_i2w ((*i)->get_canvas_group(), &ix1, &iy1);
TimeAxisView* tvp2 = trackview_by_y_position (iy1);
AudioTimeAxisView* atv2 = dynamic_cast<AudioTimeAxisView*>(tvp2);
double ix1, ix2, iy1, iy2;
- gtk_canvas_item_get_bounds (rv->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
- gtk_canvas_item_i2w (rv->get_canvas_group(), &ix1, &iy1);
+ gnome_canvas_item_get_bounds (rv->get_canvas_frame(), &ix1, &iy1, &ix2, &iy2);
+ gnome_canvas_item_i2w (rv->get_canvas_group(), &ix1, &iy1);
where = (jack_nframes_t) (unit_to_frame (ix1) * ownspeed);
} else {
}
void
-Editor::start_selection_grab (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_selection_grab (GnomeCanvasItem* item, GdkEvent* event)
{
if (clicked_regionview == 0) {
return;
}
void
-Editor::start_selection_op (GtkCanvasItem* item, GdkEvent* event, SelectionOp op)
+Editor::start_selection_op (GnomeCanvasItem* item, GdkEvent* event, SelectionOp op)
{
jack_nframes_t start = 0;
jack_nframes_t end = 0;
}
void
-Editor::drag_selection (GtkCanvasItem* item, GdkEvent* event)
+Editor::drag_selection (GnomeCanvasItem* item, GdkEvent* event)
{
jack_nframes_t start = 0;
jack_nframes_t end = 0;
}
void
-Editor::end_selection_op (GtkCanvasItem* item, GdkEvent* event)
+Editor::end_selection_op (GnomeCanvasItem* item, GdkEvent* event)
{
if (!drag_info.first_move) {
drag_selection (item, event);
}
void
-Editor::start_trim (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_trim (GnomeCanvasItem* item, GdkEvent* event)
{
double speed = 1.0;
TimeAxisView* tvp = clicked_trackview;
}
void
-Editor::trim_motion_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::trim_motion_callback (GnomeCanvasItem* item, GdkEvent* event)
{
AudioRegionView* rv = clicked_regionview;
jack_nframes_t frame_delta = 0;
}
void
-Editor::trim_finished_callback (GtkCanvasItem* item, GdkEvent* event)
+Editor::trim_finished_callback (GnomeCanvasItem* item, GdkEvent* event)
{
if (!drag_info.first_move) {
trim_motion_callback (item, event);
}
void
-Editor::hide_marker (GtkCanvasItem* item, GdkEvent* event)
+Editor::hide_marker (GnomeCanvasItem* item, GdkEvent* event)
{
Marker* marker;
bool is_start;
void
-Editor::start_range_markerbar_op (GtkCanvasItem* item, GdkEvent* event, RangeMarkerOp op)
+Editor::start_range_markerbar_op (GnomeCanvasItem* item, GdkEvent* event, RangeMarkerOp op)
{
if (session == 0) {
}
void
-Editor::drag_range_markerbar_op (GtkCanvasItem* item, GdkEvent* event)
+Editor::drag_range_markerbar_op (GnomeCanvasItem* item, GdkEvent* event)
{
jack_nframes_t start = 0;
jack_nframes_t end = 0;
- GtkCanvasItem * crect = (range_marker_op == CreateRangeMarker) ? range_bar_drag_rect: transport_bar_drag_rect;
+ GnomeCanvasItem * crect = (range_marker_op == CreateRangeMarker) ? range_bar_drag_rect: transport_bar_drag_rect;
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
snap_to (drag_info.current_pointer_frame);
temp_location->set (start, end);
- gtk_canvas_item_show (crect);
+ gnome_canvas_item_show (crect);
update_marker_drag_item (temp_location);
- gtk_canvas_item_show (range_marker_drag_rect);
- gtk_canvas_item_raise_to_top (range_marker_drag_rect);
+ gnome_canvas_item_show (range_marker_drag_rect);
+ gnome_canvas_item_raise_to_top (range_marker_drag_rect);
}
break;
double x1 = frame_to_pixel (start);
double x2 = frame_to_pixel (end);
- gtk_canvas_item_set (crect, "x1", x1, "x2", x2, NULL);
+ gnome_canvas_item_set (crect, "x1", x1, "x2", x2, NULL);
update_marker_drag_item (temp_location);
}
}
void
-Editor::end_range_markerbar_op (GtkCanvasItem* item, GdkEvent* event)
+Editor::end_range_markerbar_op (GnomeCanvasItem* item, GdkEvent* event)
{
Location * newloc = 0;
session->add_redo_no_execute (session->locations()->get_memento());
commit_reversible_command ();
- gtk_canvas_item_hide (range_bar_drag_rect);
- gtk_canvas_item_hide (range_marker_drag_rect);
+ gnome_canvas_item_hide (range_bar_drag_rect);
+ gnome_canvas_item_hide (range_marker_drag_rect);
break;
case CreateTransportMarker:
void
-Editor::start_mouse_zoom (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_mouse_zoom (GnomeCanvasItem* item, GdkEvent* event)
{
drag_info.item = item;
drag_info.motion_callback = &Editor::drag_mouse_zoom;
}
void
-Editor::drag_mouse_zoom (GtkCanvasItem* item, GdkEvent* event)
+Editor::drag_mouse_zoom (GnomeCanvasItem* item, GdkEvent* event)
{
jack_nframes_t start;
jack_nframes_t end;
if (start != end) {
if (drag_info.first_move) {
- gtk_canvas_item_show (zoom_rect);
- gtk_canvas_item_raise_to_top (zoom_rect);
+ gnome_canvas_item_show (zoom_rect);
+ gnome_canvas_item_raise_to_top (zoom_rect);
}
reposition_zoom_rect(start, end);
}
void
-Editor::end_mouse_zoom (GtkCanvasItem* item, GdkEvent* event)
+Editor::end_mouse_zoom (GnomeCanvasItem* item, GdkEvent* event)
{
if (!drag_info.first_move) {
drag_mouse_zoom (item, event);
*/
}
- gtk_canvas_item_hide (zoom_rect);
+ gnome_canvas_item_hide (zoom_rect);
}
void
}
void
-Editor::start_rubberband_select (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_rubberband_select (GnomeCanvasItem* item, GdkEvent* event)
{
drag_info.item = item;
drag_info.motion_callback = &Editor::drag_rubberband_select;
}
void
-Editor::drag_rubberband_select (GtkCanvasItem* item, GdkEvent* event)
+Editor::drag_rubberband_select (GnomeCanvasItem* item, GdkEvent* event)
{
jack_nframes_t start;
jack_nframes_t end;
"y2", y2,
NULL);
- gtk_canvas_item_show (rubberband_rect);
- gtk_canvas_item_raise_to_top (rubberband_rect);
+ gnome_canvas_item_show (rubberband_rect);
+ gnome_canvas_item_raise_to_top (rubberband_rect);
drag_info.last_pointer_frame = drag_info.current_pointer_frame;
drag_info.first_move = false;
}
void
-Editor::end_rubberband_select (GtkCanvasItem* item, GdkEvent* event)
+Editor::end_rubberband_select (GnomeCanvasItem* item, GdkEvent* event)
{
if (!drag_info.first_move) {
selection->clear_lines ();
}
- gtk_canvas_item_hide (rubberband_rect);
+ gnome_canvas_item_hide (rubberband_rect);
}
gint
-Editor::mouse_rename_region (GtkCanvasItem* item, GdkEvent* event)
+Editor::mouse_rename_region (GnomeCanvasItem* item, GdkEvent* event)
{
using namespace Gtkmm2ext;
}
void
-Editor::start_time_fx (GtkCanvasItem* item, GdkEvent* event)
+Editor::start_time_fx (GnomeCanvasItem* item, GdkEvent* event)
{
drag_info.item = item;
drag_info.motion_callback = &Editor::time_fx_motion;
}
void
-Editor::time_fx_motion (GtkCanvasItem *item, GdkEvent* event)
+Editor::time_fx_motion (GnomeCanvasItem *item, GdkEvent* event)
{
AudioRegionView* rv = clicked_regionview;
}
void
-Editor::end_time_fx (GtkCanvasItem* item, GdkEvent* event)
+Editor::end_time_fx (GnomeCanvasItem* item, GdkEvent* event)
{
clicked_regionview->get_time_axis_view().hide_timestretch ();
track_canvas->get_pointer (x, y);
- gtk_canvas_window_to_world (GTK_CANVAS(track_gtk_canvas), x, y, &wx, &wy);
+ gnome_canvas_window_to_world (GNOME_CANVAS(track_gnome_canvas), x, y, &wx, &wy);
GdkEvent event;
event.type = GDK_BUTTON_RELEASE;
double wx, wy;
track_canvas->get_pointer (x, y);
- gtk_canvas_window_to_world (GTK_CANVAS(track_gtk_canvas), x, y, &wx, &wy);
+ gnome_canvas_window_to_world (GNOME_CANVAS(track_gnome_canvas), x, y, &wx, &wy);
GdkEvent event;
event.type = GDK_BUTTON_RELEASE;
edit_controls_scroller.queue_resize ();
reset_scrolling_region ();
- //gtk_canvas_item_raise_to_top (time_line_group);
- gtk_canvas_item_raise_to_top (cursor_group);
+ //gnome_canvas_item_raise_to_top (time_line_group);
+ gnome_canvas_item_raise_to_top (cursor_group);
return FALSE;
}
time_canvas_event_box.get_window().get_pointer (x, y, state);
- gtk_canvas_window_to_world (GTK_CANVAS(track_gtk_canvas), x, y, &wcx, &wcy);
- gtk_canvas_w2c_d (GTK_CANVAS(track_gtk_canvas), wcx, wcy, &cx, &cy);
+ gnome_canvas_window_to_world (GNOME_CANVAS(track_gnome_canvas), x, y, &wcx, &wcy);
+ gnome_canvas_w2c_d (GNOME_CANVAS(track_gnome_canvas), wcx, wcy, &cx, &cy);
jack_nframes_t where = leftmost_frame + pixel_to_frame (x);
gtk_object_getv (GTK_OBJECT(meter_group), 1, args) ;
old_unit_pos = GTK_VALUE_DOUBLE (args[0]) ;
if (tbpos != old_unit_pos) {
- gtk_canvas_item_move (meter_group, 0.0, tbpos - old_unit_pos) ;
+ gnome_canvas_item_move (meter_group, 0.0, tbpos - old_unit_pos) ;
}
- //gtk_canvas_item_set (meter_group, "y", tbpos, NULL);
- gtk_canvas_item_show (meter_group);
+ //gnome_canvas_item_set (meter_group, "y", tbpos, NULL);
+ gnome_canvas_item_show (meter_group);
tbpos += timebar_height;
visible_timebars++;
}
else {
- gtk_canvas_item_hide (meter_group);
+ gnome_canvas_item_hide (meter_group);
}
if (ruler_shown[ruler_time_tempo]) {
gtk_object_getv (GTK_OBJECT(tempo_group), 1, args) ;
old_unit_pos = GTK_VALUE_DOUBLE (args[0]) ;
if (tbpos != old_unit_pos) {
- gtk_canvas_item_move (tempo_group, 0.0, tbpos - old_unit_pos) ;
+ gnome_canvas_item_move (tempo_group, 0.0, tbpos - old_unit_pos) ;
}
- //gtk_canvas_item_set (tempo_group, "y", tbpos, NULL);
- gtk_canvas_item_show (tempo_group);
+ //gnome_canvas_item_set (tempo_group, "y", tbpos, NULL);
+ gnome_canvas_item_show (tempo_group);
tbpos += timebar_height;
visible_timebars++;
}
else {
- gtk_canvas_item_hide (tempo_group);
+ gnome_canvas_item_hide (tempo_group);
}
if (ruler_shown[ruler_time_marker]) {
gtk_object_getv (GTK_OBJECT(marker_group), 1, args) ;
old_unit_pos = GTK_VALUE_DOUBLE (args[0]) ;
if (tbpos != old_unit_pos) {
- gtk_canvas_item_move (marker_group, 0.0, tbpos - old_unit_pos) ;
+ gnome_canvas_item_move (marker_group, 0.0, tbpos - old_unit_pos) ;
}
- //gtk_canvas_item_set (marker_group, "y", tbpos, NULL);
- gtk_canvas_item_show (marker_group);
+ //gnome_canvas_item_set (marker_group, "y", tbpos, NULL);
+ gnome_canvas_item_show (marker_group);
tbpos += timebar_height;
visible_timebars++;
}
else {
- gtk_canvas_item_hide (marker_group);
+ gnome_canvas_item_hide (marker_group);
}
if (ruler_shown[ruler_time_range_marker]) {
gtk_object_getv (GTK_OBJECT(range_marker_group), 1, args) ;
old_unit_pos = GTK_VALUE_DOUBLE (args[0]) ;
if (tbpos != old_unit_pos) {
- gtk_canvas_item_move (range_marker_group, 0.0, tbpos - old_unit_pos) ;
+ gnome_canvas_item_move (range_marker_group, 0.0, tbpos - old_unit_pos) ;
}
- //gtk_canvas_item_set (marker_group, "y", tbpos, NULL);
- gtk_canvas_item_show (range_marker_group);
+ //gnome_canvas_item_set (marker_group, "y", tbpos, NULL);
+ gnome_canvas_item_show (range_marker_group);
tbpos += timebar_height;
visible_timebars++;
}
else {
- gtk_canvas_item_hide (range_marker_group);
+ gnome_canvas_item_hide (range_marker_group);
}
if (ruler_shown[ruler_time_transport_marker]) {
gtk_object_getv (GTK_OBJECT(transport_marker_group), 1, args) ;
old_unit_pos = GTK_VALUE_DOUBLE (args[0]) ;
if (tbpos != old_unit_pos) {
- gtk_canvas_item_move (transport_marker_group, 0.0, tbpos - old_unit_pos) ;
+ gnome_canvas_item_move (transport_marker_group, 0.0, tbpos - old_unit_pos) ;
}
- //gtk_canvas_item_set (marker_group, "y", tbpos, NULL);
- gtk_canvas_item_show (transport_marker_group);
+ //gnome_canvas_item_set (marker_group, "y", tbpos, NULL);
+ gnome_canvas_item_show (transport_marker_group);
tbpos += timebar_height;
visible_timebars++;
}
else {
- gtk_canvas_item_hide (transport_marker_group);
+ gnome_canvas_item_hide (transport_marker_group);
}
time_canvas_vbox.set_size_request (-1, (int)(timebar_height * visible_timebars));
#include <string>
#include <climits>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <pbd/error.h>
if ((ms = dynamic_cast<const MeterSection*>(*i)) != 0) {
snprintf (buf, sizeof(buf), "%g/%g", ms->beats_per_bar(), ms->note_divisor ());
- metric_marks.push_back (new MeterMarker (*this, GTK_CANVAS_GROUP(meter_group), color_map[cMeterMarker], buf,
+ metric_marks.push_back (new MeterMarker (*this, GNOME_CANVAS_GROUP(meter_group), color_map[cMeterMarker], buf,
*(const_cast<MeterSection*>(ms)), PublicEditor::canvas_meter_marker_event));
} else if ((ts = dynamic_cast<const TempoSection*>(*i)) != 0) {
snprintf (buf, sizeof (buf), "%.2f", ts->beats_per_minute());
- metric_marks.push_back (new TempoMarker (*this, GTK_CANVAS_GROUP(tempo_group), color_map[cTempoMarker], buf,
+ metric_marks.push_back (new TempoMarker (*this, GNOME_CANVAS_GROUP(tempo_group), color_map[cTempoMarker], buf,
*(const_cast<TempoSection*>(ts)), PublicEditor::canvas_tempo_marker_event));
}
Editor::hide_measures ()
{
for (TimeLineList::iterator i = used_measure_lines.begin(); i != used_measure_lines.end(); ++i) {
- gtk_canvas_item_hide (*i);
+ gnome_canvas_item_hide (*i);
free_measure_lines.push_back (*i);
}
used_measure_lines.clear ();
}
-GtkCanvasItem *
+GnomeCanvasItem *
Editor::get_time_line ()
{
- GtkCanvasItem *line;
+ GnomeCanvasItem *line;
if (free_measure_lines.empty()) {
- line = gtk_canvas_item_new (GTK_CANVAS_GROUP(time_line_group),
- gtk_canvas_simpleline_get_type(),
+ line = gnome_canvas_item_new (GNOME_CANVAS_GROUP(time_line_group),
+ gnome_canvas_simpleline_get_type(),
NULL);
// cerr << "measure line @ " << line << endl;
used_measure_lines.push_back (line);
TempoMap::BBTPointList::iterator i;
TempoMap::BBTPointList *all_bbt_points;
- GtkCanvasItem *line;
+ GnomeCanvasItem *line;
gdouble xpos, last_xpos;
uint32_t cnt;
uint32_t color;
"y2", (gdouble) canvas_height,
"color_rgba", color,
NULL);
- gtk_canvas_item_raise_to_top (line);
- gtk_canvas_item_show (line);
+ gnome_canvas_item_raise_to_top (line);
+ gnome_canvas_item_show (line);
last_xpos = xpos;
++cnt;
}
/* the cursors are always on top of everything */
- gtk_canvas_item_raise_to_top (cursor_group);
- gtk_canvas_item_lower_to_bottom (time_line_group);
+ gnome_canvas_item_raise_to_top (cursor_group);
+ gnome_canvas_item_lower_to_bottom (time_line_group);
}
void
}
void
-Editor::remove_tempo_marker (GtkCanvasItem* item)
+Editor::remove_tempo_marker (GnomeCanvasItem* item)
{
Marker* marker;
TempoMarker* tempo_marker;
}
void
-Editor::edit_tempo_marker (GtkCanvasItem *item)
+Editor::edit_tempo_marker (GnomeCanvasItem *item)
{
Marker* marker;
TempoMarker* tempo_marker;
}
void
-Editor::edit_meter_marker (GtkCanvasItem *item)
+Editor::edit_meter_marker (GnomeCanvasItem *item)
{
Marker* marker;
MeterMarker* meter_marker;
}
void
-Editor::remove_meter_marker (GtkCanvasItem* item)
+Editor::remove_meter_marker (GnomeCanvasItem* item)
{
Marker* marker;
MeterMarker* meter_marker;
Narrow,
};
-#include <gtk-canvas/gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
struct SelectionRect {
- GtkCanvasItem *rect;
- GtkCanvasItem *end_trim;
- GtkCanvasItem *start_trim;
+ GnomeCanvasItem *rect;
+ GnomeCanvasItem *end_trim;
+ GnomeCanvasItem *start_trim;
uint32_t id;
};
#include <sigc++/adaptor.h>
#include <sigc++/scope.h>
-namespace SigC
+namespace sigc
{
/****************************************************************
}
void
-GainAutomationTimeAxisView::add_automation_event (GtkCanvasItem* item, GdkEvent* event, jack_nframes_t when, double y)
+GainAutomationTimeAxisView::add_automation_event (GnomeCanvasItem* item, GdkEvent* event, jack_nframes_t when, double y)
{
double x = 0;
- gtk_canvas_item_w2i (canvas_display, &x, &y);
+ gnome_canvas_item_w2i (canvas_display, &x, &y);
/* compute vertical fractional position */
~GainAutomationTimeAxisView();
- void add_automation_event (GtkCanvasItem *item, GdkEvent *event, jack_nframes_t, double);
+ void add_automation_event (GnomeCanvasItem *item, GdkEvent *event, jack_nframes_t, double);
private:
ARDOUR::Curve& curve;
#include <ardour/types.h>
-#include <gtk--.h>
-#include <gtkmmext/slider_controller.h>
-#include <gtkmmext/click_box.h>
+#include <gtkmm.h>
+#include <gtkmm2ext/slider_controller.h>
+#include <gtkmm2ext/click_box.h>
#include "enums.h"
class Route;
class RouteGroup;
}
-namespace Gtkmmext {
+namespace Gtkmm2ext {
class FastMeter;
class BarController;
class Pix;
bool ignore_toggle;
- Gtkmmext::VSliderController *gain_slider;
+ Gtkmm2ext::VSliderController *gain_slider;
Gtk::Adjustment gain_adjustment;
Gtk::Frame gain_display_frame;
- Gtkmmext::ClickBox gain_display;
+ Gtkmm2ext::ClickBox gain_display;
Gtk::Frame peak_display_frame;
Gtk::EventBox peak_display;
Gtk::Label peak_display_label;
void gain_printer (char buf[32], Gtk::Adjustment&);
struct MeterInfo {
- Gtkmmext::FastMeter *meter;
+ Gtkmm2ext::FastMeter *meter;
gint16 width;
bool packed;
void reset_peak_display ();
void reset_group_peak_display (ARDOUR::RouteGroup*);
- static SigC::Signal0<void> ResetAllPeakDisplays;
- static SigC::Signal1<void,ARDOUR::RouteGroup*> ResetGroupPeakDisplays;
+ static sigc::signal<void> ResetAllPeakDisplays;
+ static sigc::signal<void,ARDOUR::RouteGroup*> ResetGroupPeakDisplays;
- static Gtkmmext::Pix* slider_pix;
+ static Gtkmm2ext::Pix* slider_pix;
static int setup_slider_pix ();
};
GhostRegion::GhostRegion (AutomationTimeAxisView& atv, double initial_pos)
: trackview (atv)
{
- group = gtk_canvas_item_new (GTK_CANVAS_GROUP(trackview.canvas_display),
- gtk_canvas_group_get_type(),
+ group = gnome_canvas_item_new (GNOME_CANVAS_GROUP(trackview.canvas_display),
+ gnome_canvas_group_get_type(),
"x", initial_pos,
"y", 0.0,
NULL);
- base_rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
+ base_rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simplerect_get_type(),
"x1", (double) 0.0,
"y1", (double) 0.0,
"y2", (double) trackview.height,
"fill_color_rgba", color_map[cGhostTrackBaseFill],
NULL);
- gtk_canvas_item_lower_to_bottom (group);
+ gnome_canvas_item_lower_to_bottom (group);
atv.add_ghost (this);
}
void
GhostRegion::set_samples_per_unit (double spu)
{
- for (vector<GtkCanvasItem*>::iterator i = waves.begin(); i != waves.end(); ++i) {
- gtk_canvas_item_set ((*i), "samples_per_unit", spu, NULL);
+ for (vector<GnomeCanvasItem*>::iterator i = waves.begin(); i != waves.end(); ++i) {
+ gnome_canvas_item_set ((*i), "samples_per_unit", spu, NULL);
}
}
void
GhostRegion::set_duration (double units)
{
- gtk_canvas_item_set (base_rect, "x2", units, NULL);
+ gnome_canvas_item_set (base_rect, "x2", units, NULL);
}
void
GhostRegion::set_height ()
{
gdouble ht;
- vector<GtkCanvasItem*>::iterator i;
+ vector<GnomeCanvasItem*>::iterator i;
uint32_t n;
- gtk_canvas_item_set (base_rect, "y2", (double) trackview.height, NULL);
+ gnome_canvas_item_set (base_rect, "y2", (double) trackview.height, NULL);
ht = ((trackview.height) / (double) waves.size());
for (n = 0, i = waves.begin(); i != waves.end(); ++i, ++n) {
gdouble yoff = n * ht;
- gtk_canvas_item_set ((*i), "height", ht, "y", yoff, NULL);
+ gnome_canvas_item_set ((*i), "height", ht, "y", yoff, NULL);
}
}
#include <vector>
#include <sigc++/signal.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
class AutomationTimeAxisView;
struct GhostRegion : public sigc::trackable
{
AutomationTimeAxisView& trackview;
- GtkCanvasItem* group;
- GtkCanvasItem* base_rect;
- std::vector<GtkCanvasItem*> waves;
+ GnomeCanvasItem* group;
+ GnomeCanvasItem* base_rect;
+ std::vector<GnomeCanvasItem*> waves;
GhostRegion (AutomationTimeAxisView& tv, double initial_unit_pos);
~GhostRegion ();
widget = GTK_WIDGET (ruler);
- gc = widget->style->fg_gc[GTK_STATE_NORMAL];
- bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
+ gc = widget->style->fg_gc[Gtk::STATE_NORMAL];
+ bg_gc = widget->style->bg_gc[Gtk::STATE_NORMAL];
font = gtk_style_get_font(widget->style);
gtk_paint_box (widget->style, ruler->backing_store,
- GTK_STATE_NORMAL, GTK_SHADOW_NONE,
+ Gtk::STATE_NORMAL, GTK_SHADOW_NONE,
NULL, widget, "custom_hruler", 0, 0, widget->allocation.width, widget->allocation.height);
gdk_draw_line (ruler->backing_store, gc, 0, widget->allocation.height - 1,
g_return_if_fail (GTK_IS_CUSTOM_HRULER (ruler));
if (GTK_WIDGET_DRAWABLE (ruler) && (ruler->upper - ruler->lower) > 0) {
widget = GTK_WIDGET (ruler);
- gc = widget->style->fg_gc[GTK_STATE_NORMAL];
+ gc = widget->style->fg_gc[Gtk::STATE_NORMAL];
xthickness = widget->style->xthickness;
ythickness = widget->style->ythickness;
width = widget->allocation.width;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = gtk_widget_get_events (widget);
- attributes.event_mask |= (GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
+ attributes.event_mask |= (GDK_EXPOSURE_MASK | Gdk::POINTER_MOTION_MASK | Gdk::POINTER_MOTION_HINT_MASK);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
* to be best suited to display its contents, including children.
* the width and/or height reported from a widget upon size requisition
* may be overidden by the user by specifying a width and/or height
- * other than 0 through gtk_widget_set_usize().
+ * other than 0 through gtk_widget_set_size_request().
*
* a scrolled window needs (for imlementing all three policy types) to
* request its width and height based on two different rationales.
gtk_widget_size_request (bin->child, &child_requisition);
- if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
+ if (scrolled_window->hscrollbar_policy == Gtk::POLICY_NEVER)
requisition->width += child_requisition.width;
else
{
requisition->width += vscrollbar_requisition.width;
}
-// if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
+// if (scrolled_window->vscrollbar_policy == Gtk::POLICY_NEVER)
// requisition->height += child_requisition.height;
// else
{
}
}
- if (scrolled_window->hscrollbar_policy == GTK_POLICY_AUTOMATIC ||
+ if (scrolled_window->hscrollbar_policy == Gtk::POLICY_AUTOMATIC ||
scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
{
requisition->width = MAX (requisition->width, hscrollbar_requisition.width);
extra_height = SCROLLBAR_SPACING (scrolled_window) + hscrollbar_requisition.height;
}
- if (scrolled_window->vscrollbar_policy == GTK_POLICY_AUTOMATIC ||
+ if (scrolled_window->vscrollbar_policy == Gtk::POLICY_AUTOMATIC ||
scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
{
requisition->height = MAX (requisition->height, vscrollbar_requisition.height);
if (scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
scrolled_window->hscrollbar_visible = TRUE;
- else if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
+ else if (scrolled_window->hscrollbar_policy == Gtk::POLICY_NEVER)
scrolled_window->hscrollbar_visible = FALSE;
if (scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
scrolled_window->vscrollbar_visible = TRUE;
- else if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
+ else if (scrolled_window->vscrollbar_policy == Gtk::POLICY_NEVER)
scrolled_window->vscrollbar_visible = FALSE;
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->hscrollbar)))
{
- if (scrolled_win->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
+ if (scrolled_win->hscrollbar_policy == Gtk::POLICY_AUTOMATIC)
{
gboolean visible;
}
else if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->vscrollbar)))
{
- if (scrolled_win->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
+ if (scrolled_win->vscrollbar_policy == Gtk::POLICY_AUTOMATIC)
{
gboolean visible;
{
_color = unique_random_color() ;
- selection_group = gtk_canvas_item_new (GTK_CANVAS_GROUP(canvas_display), gtk_canvas_group_get_type (), NULL) ;
- gtk_canvas_item_hide(selection_group) ;
+ selection_group = gnome_canvas_item_new (GNOME_CANVAS_GROUP(canvas_display), gnome_canvas_group_get_type (), NULL) ;
+ gnome_canvas_item_hide(selection_group) ;
// intialize our data items
_marked_for_display = true;
#define __ardour_imageframe_time_axis_h__
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include "ardour_dialog.h"
#include "enums.h"
if(get_named_imageframe_item(frame_id) == 0)
{
ifv = new ImageFrameView(frame_id,
- GTK_CANVAS_GROUP(_view_helper.canvas_item()),
+ GNOME_CANVAS_GROUP(_view_helper.canvas_item()),
&(_view_helper.trackview()),
this,
_view_helper.trackview().editor.get_current_zoom(),
#include <cmath>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <jack/jack.h>
#include "imageframe_time_axis_view.h"
region_color = _trackview.color() ;
stream_base_color = color_map[cImageTrackBase] ;
- canvas_group = gtk_canvas_item_new (GTK_CANVAS_GROUP(_trackview.canvas_display), gtk_canvas_group_get_type (), 0) ;
+ canvas_group = gnome_canvas_item_new (GNOME_CANVAS_GROUP(_trackview.canvas_display), gnome_canvas_group_get_type (), 0) ;
- canvas_rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(canvas_group),
- gtk_canvas_simplerect_get_type(),
+ canvas_rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(canvas_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 1000000.0,
ImageFrameTimeAxisView::set_position (gdouble x, gdouble y)
{
- gtk_canvas_item_set (canvas_group, "x", x, "y", y, NULL);
+ gnome_canvas_item_set (canvas_group, "x", x, "y", y, NULL);
return 0;
}
#include <cmath>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <jack/jack.h>
class PublicEditor ;
/**
*
*/
- GtkCanvasItem* canvas_item() { return canvas_group; }
+ GnomeCanvasItem* canvas_item() { return canvas_group; }
//---------------------------------------------------------------------------------------//
/* the TimeAxisView that this object is acting as the view helper for */
ImageFrameTimeAxis& _trackview ;
- GtkCanvasItem *canvas_group ;
- GtkCanvasItem *canvas_rect; /* frame around the whole thing */
+ GnomeCanvasItem *canvas_group ;
+ GnomeCanvasItem *canvas_rect; /* frame around the whole thing */
/** the current samples per unit */
double _samples_per_unit ;
* @param num_channels the number of color channels within rgb_data
*/
ImageFrameView::ImageFrameView(std::string item_id,
- GtkCanvasGroup *parent,
+ GnomeCanvasGroup *parent,
ImageFrameTimeAxis* tv,
ImageFrameTimeAxisGroup* item_group,
double spu,
double im_ratio = (double)width/(double)height ;
int im_width = (int)((double)(trackview.height - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE) * im_ratio) ;
- imageframe = gtk_canvas_item_new(GTK_CANVAS_GROUP(group),
- gtk_canvas_imageframe_get_type(),
+ imageframe = gnome_canvas_item_new(GNOME_CANVAS_GROUP(group),
+ gnome_canvas_imageframe_get_type(),
"pixbuf", pbuf,
"x", (gdouble) 1.0,
"y", (gdouble) 1.0,
/* handle any specific details required by the initial start end duration values */
- gtk_canvas_item_raise_to_top(frame_handle_start) ;
- gtk_canvas_item_raise_to_top(frame_handle_end) ;
+ gnome_canvas_item_raise_to_top(frame_handle_start) ;
+ gnome_canvas_item_raise_to_top(frame_handle_end) ;
set_position(start, this) ;
set_duration(duration, this) ;
if(ret)
{
/* handle setting the sizes of our canvas itesm based on the new duration */
- gtk_canvas_item_set(imageframe, "drawwidth", (gdouble) trackview.editor.frame_to_pixel(get_duration()), NULL) ;
+ gnome_canvas_item_set(imageframe, "drawwidth", (gdouble) trackview.editor.frame_to_pixel(get_duration()), NULL) ;
}
return(ret) ;
// @todo might have to re-get the image data, for a large height...hmmm.
double im_ratio = (double)image_data_width/(double)image_data_height ;
int im_width = (int)((double)(h - TimeAxisViewItem::NAME_Y_OFFSET) * im_ratio) ;
- gtk_canvas_item_set(imageframe, "width", (gdouble)im_width, NULL) ;
- gtk_canvas_item_set(imageframe, "height",(gdouble) (h - TimeAxisViewItem::NAME_Y_OFFSET), NULL) ;
+ gnome_canvas_item_set(imageframe, "width", (gdouble)im_width, NULL) ;
+ gnome_canvas_item_set(imageframe, "height",(gdouble) (h - TimeAxisViewItem::NAME_Y_OFFSET), NULL) ;
- gtk_canvas_item_raise_to_top(frame) ;
- gtk_canvas_item_raise_to_top(imageframe) ;
- gtk_canvas_item_raise_to_top(name_highlight) ;
- gtk_canvas_item_raise_to_top(name_text) ;
- gtk_canvas_item_raise_to_top(frame_handle_start) ;
- gtk_canvas_item_raise_to_top(frame_handle_end) ;
+ gnome_canvas_item_raise_to_top(frame) ;
+ gnome_canvas_item_raise_to_top(imageframe) ;
+ gnome_canvas_item_raise_to_top(name_highlight) ;
+ gnome_canvas_item_raise_to_top(name_text) ;
+ gnome_canvas_item_raise_to_top(frame_handle_start) ;
+ gnome_canvas_item_raise_to_top(frame_handle_end) ;
- gtk_canvas_item_set (name_text, "y", h - TimeAxisViewItem::NAME_Y_OFFSET, NULL);
- gtk_canvas_item_set (frame, "y2", h, NULL);
+ gnome_canvas_item_set (name_text, "y", h - TimeAxisViewItem::NAME_Y_OFFSET, NULL);
+ gnome_canvas_item_set (frame, "y2", h, NULL);
- gtk_canvas_item_set (name_highlight, "y1", (gdouble) h - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE, "y2", (gdouble) h - 1.0, NULL);
+ gnome_canvas_item_set (name_highlight, "y1", (gdouble) h - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE, "y2", (gdouble) h - 1.0, NULL);
}
#include <string>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <sigc++/signal.h>
#include <list>
* @param num_channels the number of color channels within rgb_data
*/
ImageFrameView(std::string item_id,
- GtkCanvasGroup *parent,
+ GnomeCanvasGroup *parent,
ImageFrameTimeAxis *tv,
ImageFrameTimeAxisGroup* group,
double spu,
// ------- Our canvas element -----------
/** the CanvasImageFrame to display the image */
- GtkCanvasItem* imageframe ;
+ GnomeCanvasItem* imageframe ;
} ; /* class ImageFrameView */
#include "i18n.h"
-Marker::Marker (PublicEditor& ed, GtkCanvasGroup *parent, guint32 rgba, const string& annotation,
- Type type, gint (*callback)(GtkCanvasItem *, GdkEvent *, gpointer), jack_nframes_t frame)
+Marker::Marker (PublicEditor& ed, GnomeCanvasGroup *parent, guint32 rgba, const string& annotation,
+ Type type, gint (*callback)(GnomeCanvasItem *, GdkEvent *, gpointer), jack_nframes_t frame)
: editor (ed), _type(type)
{
switch (type) {
case Mark:
- points = gtk_canvas_points_new (6);
+ points = gnome_canvas_points_new (6);
points->coords[0] = 0.0;
points->coords[1] = 0.0;
case Tempo:
case Meter:
- points = gtk_canvas_points_new (6);
+ points = gnome_canvas_points_new (6);
points->coords[0] = 3.0;
points->coords[1] = 0.0;
break;
case Start:
- points = gtk_canvas_points_new (6);
+ points = gnome_canvas_points_new (6);
points->coords[0] = 0.0;
points->coords[1] = 0.0;
break;
case End:
- points = gtk_canvas_points_new (6);
+ points = gnome_canvas_points_new (6);
points->coords[0] = 5.0;
points->coords[1] = 0.0;
break;
case LoopStart:
- points = gtk_canvas_points_new (7);
+ points = gnome_canvas_points_new (7);
points->coords[0] = 0.0;
points->coords[1] = 0.0;
break;
case LoopEnd:
- points = gtk_canvas_points_new (7);
+ points = gnome_canvas_points_new (7);
points->coords[0] = 8.0;
points->coords[1] = 0.0;
break;
case PunchIn:
- points = gtk_canvas_points_new (6);
+ points = gnome_canvas_points_new (6);
points->coords[0] = 0.0;
points->coords[1] = 0.0;
break;
case PunchOut:
- points = gtk_canvas_points_new (6);
+ points = gnome_canvas_points_new (6);
points->coords[0] = 0.0;
points->coords[1] = 0.0;
unit_position -= shift;
- group = gtk_canvas_item_new (parent,
- gtk_canvas_group_get_type(),
+ group = gnome_canvas_item_new (parent,
+ gnome_canvas_group_get_type(),
"x", unit_position,
"y", 1.0,
NULL);
// cerr << "set mark al points, nc = " << points->num_points << endl;
- mark = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_polygon_get_type(),
+ mark = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_polygon_get_type(),
"points", points,
"fill_color_rgba", rgba,
"outline_color", "black",
string fontname = get_font_for_style (N_("MarkerText"));
- text = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_text_get_type (),
+ text = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_text_get_type (),
"text", annotation.c_str(),
"x", label_offset,
"y", 0.0,
{
/* destroying the group destroys its contents */
gtk_object_destroy (GTK_OBJECT(group));
- gtk_canvas_points_unref (points);
+ gnome_canvas_points_unref (points);
}
void
Marker::set_name (const string& name)
{
- gtk_canvas_item_set (text, "text", name.c_str(), NULL);
+ gnome_canvas_item_set (text, "text", name.c_str(), NULL);
}
void
{
double new_unit_position = editor.frame_to_unit (frame);
new_unit_position -= shift;
- gtk_canvas_item_move (group, new_unit_position - unit_position, 0.0);
+ gnome_canvas_item_move (group, new_unit_position - unit_position, 0.0);
frame_position = frame;
unit_position = new_unit_position;
}
void
Marker::show ()
{
- gtk_canvas_item_show (group);
+ gnome_canvas_item_show (group);
}
void
Marker::hide ()
{
- gtk_canvas_item_hide (group);
+ gnome_canvas_item_hide (group);
}
void
Marker::set_color_rgba (uint32_t color)
{
- gtk_canvas_item_set (mark, "fill_color_rgba", color, NULL);
+ gnome_canvas_item_set (mark, "fill_color_rgba", color, NULL);
}
/***********************************************************************/
-TempoMarker::TempoMarker (PublicEditor& editor, GtkCanvasGroup *parent, guint32 rgba, const string& text,
+TempoMarker::TempoMarker (PublicEditor& editor, GnomeCanvasGroup *parent, guint32 rgba, const string& text,
ARDOUR::TempoSection& temp,
- gint (*callback)(GtkCanvasItem *, GdkEvent *, gpointer))
+ gint (*callback)(GnomeCanvasItem *, GdkEvent *, gpointer))
: Marker (editor, parent, rgba, text, Tempo, callback, 0),
_tempo (temp)
{
/***********************************************************************/
-MeterMarker::MeterMarker (PublicEditor& editor, GtkCanvasGroup *parent, guint32 rgba, const string& text,
+MeterMarker::MeterMarker (PublicEditor& editor, GnomeCanvasGroup *parent, guint32 rgba, const string& text,
ARDOUR::MeterSection& m,
- gint (*callback)(GtkCanvasItem *, GdkEvent *, gpointer))
+ gint (*callback)(GnomeCanvasItem *, GdkEvent *, gpointer))
: Marker (editor, parent, rgba, text, Meter, callback, 0),
_meter (m)
{
#include <string>
#include <glib.h>
#include <ardour/ardour.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <sigc++/signal.h>
namespace ARDOUR {
PunchOut
};
- Marker (PublicEditor& editor, GtkCanvasGroup *parent, guint32 rgba, const string& text, Type,
- gint (*callback)(GtkCanvasItem *, GdkEvent *, gpointer), jack_nframes_t frame = 0);
+ Marker (PublicEditor& editor, GnomeCanvasGroup *parent, guint32 rgba, const string& text, Type,
+ gint (*callback)(GnomeCanvasItem *, GdkEvent *, gpointer), jack_nframes_t frame = 0);
virtual ~Marker ();
void set_position (jack_nframes_t);
protected:
PublicEditor& editor;
- GtkCanvasItem *group;
- GtkCanvasItem *mark;
- GtkCanvasItem *text;
- GtkCanvasPoints *points;
+ GnomeCanvasItem *group;
+ GnomeCanvasItem *mark;
+ GnomeCanvasItem *text;
+ GnomeCanvasPoints *points;
double unit_position;
jack_nframes_t frame_position;
class TempoMarker : public Marker
{
public:
- TempoMarker (PublicEditor& editor, GtkCanvasGroup *parent, guint32 rgba, const string& text, ARDOUR::TempoSection&,
- gint (*callback)(GtkCanvasItem *, GdkEvent *, gpointer));
+ TempoMarker (PublicEditor& editor, GnomeCanvasGroup *parent, guint32 rgba, const string& text, ARDOUR::TempoSection&,
+ gint (*callback)(GnomeCanvasItem *, GdkEvent *, gpointer));
~TempoMarker ();
ARDOUR::TempoSection& tempo() const { return _tempo; }
class MeterMarker : public Marker
{
public:
- MeterMarker (PublicEditor& editor, GtkCanvasGroup *parent, guint32 rgba, const string& text, ARDOUR::MeterSection&,
- gint (*callback)(GtkCanvasItem *, GdkEvent *, gpointer));
+ MeterMarker (PublicEditor& editor, GnomeCanvasGroup *parent, guint32 rgba, const string& text, ARDOUR::MeterSection&,
+ gint (*callback)(GnomeCanvasItem *, GdkEvent *, gpointer));
~MeterMarker ();
ARDOUR::MeterSection& meter() const { return _meter; }
_color = unique_random_color() ;
time_axis_name = name ;
- selection_group = gtk_canvas_item_new (GTK_CANVAS_GROUP(canvas_display), gtk_canvas_group_get_type (), 0) ;
- gtk_canvas_item_hide(selection_group) ;
+ selection_group = gnome_canvas_item_new (GNOME_CANVAS_GROUP(canvas_display), gnome_canvas_group_get_type (), 0) ;
+ gnome_canvas_item_hide(selection_group) ;
// intialize our data items
name_prompter = 0 ;
#define __ardour_marker_time_axis_h__
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include "ardour_dialog.h"
#include "route_ui.h"
region_color = _trackview.color();
stream_base_color = color_map[cMarkerTrackBase];
- canvas_group = gtk_canvas_item_new (GTK_CANVAS_GROUP(_trackview.canvas_display), gtk_canvas_group_get_type (), 0);
+ canvas_group = gnome_canvas_item_new (GNOME_CANVAS_GROUP(_trackview.canvas_display), gnome_canvas_group_get_type (), 0);
- canvas_rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(canvas_group),
- gtk_canvas_simplerect_get_type(),
+ canvas_rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(canvas_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 1000000.0,
int
MarkerTimeAxisView::set_position(gdouble x, gdouble y)
{
- gtk_canvas_item_set (canvas_group, "x", x, "y", y, NULL);
+ gnome_canvas_item_set (canvas_group, "x", x, "y", y, NULL);
return 0;
}
return(0) ;
}
- MarkerView* mv = new MarkerView(GTK_CANVAS_GROUP(canvas_group),
+ MarkerView* mv = new MarkerView(GNOME_CANVAS_GROUP(canvas_group),
&_trackview,
ifv,
_trackview.editor.get_current_zoom(),
#include <list>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <ardour/location.h>
/**
*
*/
- GtkCanvasItem *canvas_item() { return canvas_group; }
+ GnomeCanvasItem *canvas_item() { return canvas_group; }
//---------------------------------------------------------------------------------------//
/* the TimeAxisView that this object is acting as the view helper for */
MarkerTimeAxis& _trackview ;
- GtkCanvasItem *canvas_group ;
- GtkCanvasItem *canvas_rect ; /* frame around the whole thing */
+ GnomeCanvasItem *canvas_group ;
+ GnomeCanvasItem *canvas_rect ; /* frame around the whole thing */
/** the current samples per unit */
double _samples_per_unit;
* @param start the start time of this item
* @param duration the duration of this item
*/
-MarkerView::MarkerView(GtkCanvasGroup *parent,
+MarkerView::MarkerView(GnomeCanvasGroup *parent,
TimeAxisView* tv,
ImageFrameView* marked,
double spu,
#include <string>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include "time_axis_view_item.h"
class MarkerTimeAxisView ;
* @param start the start time of this item
* @param duration the duration of this item
*/
- MarkerView(GtkCanvasGroup *parent,
+ MarkerView(GnomeCanvasGroup *parent,
TimeAxisView *tv,
ImageFrameView* marked,
double spu,
}
void
-PanAutomationTimeAxisView::add_automation_event (GtkCanvasItem* item, GdkEvent* event, jack_nframes_t when, double y)
+PanAutomationTimeAxisView::add_automation_event (GnomeCanvasItem* item, GdkEvent* event, jack_nframes_t when, double y)
{
if (lines.empty()) {
/* no data, possibly caused by no outputs/inputs */
double x = 0;
- gtk_canvas_item_w2i (canvas_display, &x, &y);
+ gnome_canvas_item_w2i (canvas_display, &x, &y);
/* compute vertical fractional position */
~PanAutomationTimeAxisView();
- void add_automation_event (GtkCanvasItem *item, GdkEvent *event, jack_nframes_t, double);
+ void add_automation_event (GnomeCanvasItem *item, GdkEvent *event, jack_nframes_t, double);
private:
void automation_changed ();
}
gint
-PublicEditor::canvas_fade_in_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_fade_in_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_fade_in_event (item, event, data);
}
gint
-PublicEditor::canvas_fade_in_handle_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_fade_in_handle_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_fade_in_handle_event (item, event, data);
}
gint
-PublicEditor::canvas_fade_out_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_fade_out_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_fade_out_event (item, event, data);
}
gint
-PublicEditor::canvas_fade_out_handle_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_fade_out_handle_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_fade_out_handle_event (item, event, data);
}
gint
-PublicEditor::canvas_crossfade_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_crossfade_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_crossfade_view_event (item, event, data);
}
gint
-PublicEditor::canvas_region_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_region_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_region_view_event (item, event, data);
}
gint
-PublicEditor::canvas_region_view_name_highlight_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_region_view_name_highlight_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_region_view_name_highlight_event (item, event, data);
}
gint
-PublicEditor::canvas_region_view_name_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_region_view_name_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_region_view_name_event (item, event, data);
}
gint
-PublicEditor::canvas_stream_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_stream_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_stream_view_event (item, event, data);
}
gint
-PublicEditor::canvas_automation_track_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_automation_track_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_automation_track_event (item, event, data);
}
gint
-PublicEditor::canvas_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_marker_event (item, event, data);
}
gint
-PublicEditor::canvas_zoom_rect_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_zoom_rect_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_zoom_rect_event (item, event, data);
}
gint
-PublicEditor::canvas_selection_rect_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_selection_rect_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_selection_rect_event (item, event, data);
}
gint
-PublicEditor::canvas_selection_start_trim_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_selection_start_trim_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_selection_start_trim_event (item, event, data);
}
gint
-PublicEditor::canvas_selection_end_trim_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_selection_end_trim_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_selection_end_trim_event (item, event, data);
}
gint
-PublicEditor::canvas_control_point_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_control_point_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_control_point_event (item, event, data);
}
gint
-PublicEditor::canvas_line_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_line_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_line_event (item, event, data);
}
gint
-PublicEditor::canvas_tempo_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_tempo_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_tempo_marker_event (item, event, data);
}
gint
-PublicEditor::canvas_meter_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_meter_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_meter_marker_event (item, event, data);
}
gint
-PublicEditor::canvas_tempo_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_tempo_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_tempo_bar_event (item, event, data);
}
gint
-PublicEditor::canvas_meter_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_meter_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_meter_bar_event (item, event, data);
}
gint
-PublicEditor::canvas_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_marker_bar_event (item, event, data);
}
gint
-PublicEditor::canvas_range_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_range_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_range_marker_bar_event (item, event, data);
}
gint
-PublicEditor::canvas_transport_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_transport_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_transport_marker_bar_event (item, event, data);
}
gint
-PublicEditor::canvas_imageframe_item_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_imageframe_item_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data) {
return instance()->_canvas_imageframe_item_view_event(item, event, data);
}
gint
-PublicEditor::canvas_imageframe_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_imageframe_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data) {
return instance()->_canvas_imageframe_view_event(item, event, data);
}
gint
-PublicEditor::canvas_imageframe_start_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_imageframe_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_imageframe_start_handle_event(item, event, data);
}
gint
-PublicEditor::canvas_imageframe_end_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_imageframe_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_imageframe_end_handle_event(item, event, data);
}
gint
-PublicEditor::canvas_marker_time_axis_view_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_marker_time_axis_view_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_marker_time_axis_view_event(item, event, data);
}
gint
-PublicEditor::canvas_markerview_item_view_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_markerview_item_view_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_markerview_item_view_event(item, event, data);
}
gint
-PublicEditor::canvas_markerview_start_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_markerview_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_markerview_start_handle_event(item, event, data);
}
gint
-PublicEditor::canvas_markerview_end_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) {
+PublicEditor::canvas_markerview_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) {
return instance()->_canvas_markerview_end_handle_event(item, event, data);
}
#include <string>
#include <glib.h>
#include <gdk/gdktypes.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <gtkmm/window.h>
#include <jack/types.h>
#include <sigc++/signal.h>
sigc::signal<void> XOriginChanged;
sigc::signal<void> Resized;
- static gint canvas_crossfade_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_fade_in_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_fade_in_handle_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_fade_out_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_fade_out_handle_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_region_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_region_view_name_highlight_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_region_view_name_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_stream_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_zoom_rect_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_selection_rect_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_selection_start_trim_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_selection_end_trim_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_control_point_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_line_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_tempo_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_meter_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_tempo_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_meter_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_range_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_transport_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data);
- static gint canvas_imageframe_item_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data) ;
- static gint canvas_imageframe_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data) ;
- static gint canvas_imageframe_start_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- static gint canvas_imageframe_end_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- static gint canvas_marker_time_axis_view_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- static gint canvas_markerview_item_view_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- static gint canvas_markerview_start_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- static gint canvas_markerview_end_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
- static gint canvas_automation_track_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) ;
+ static gint canvas_crossfade_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_fade_in_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_fade_in_handle_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_fade_out_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_fade_out_handle_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_region_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_region_view_name_highlight_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_region_view_name_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_stream_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_zoom_rect_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_selection_rect_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_selection_start_trim_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_selection_end_trim_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_control_point_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_line_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_tempo_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_meter_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_tempo_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_meter_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_range_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_transport_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data);
+ static gint canvas_imageframe_item_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data) ;
+ static gint canvas_imageframe_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data) ;
+ static gint canvas_imageframe_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ static gint canvas_imageframe_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ static gint canvas_marker_time_axis_view_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ static gint canvas_markerview_item_view_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ static gint canvas_markerview_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ static gint canvas_markerview_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
+ static gint canvas_automation_track_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) ;
protected:
- virtual gint _canvas_fade_in_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_fade_in_handle_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_fade_out_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_fade_out_handle_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_crossfade_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_region_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_region_view_name_highlight_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_region_view_name_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_stream_view_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_zoom_rect_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_selection_rect_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_selection_start_trim_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_selection_end_trim_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_control_point_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_line_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_tempo_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_meter_marker_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_tempo_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_meter_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_range_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_transport_marker_bar_event (GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_imageframe_item_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_imageframe_view_event(GtkCanvasItem *item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_imageframe_start_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_imageframe_end_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_marker_time_axis_view_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_markerview_item_view_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_markerview_start_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_markerview_end_handle_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
- virtual gint _canvas_automation_track_event(GtkCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_fade_in_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_fade_in_handle_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_fade_out_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_fade_out_handle_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_crossfade_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_region_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_region_view_name_highlight_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_region_view_name_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_stream_view_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_zoom_rect_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_selection_rect_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_selection_start_trim_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_selection_end_trim_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_control_point_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_line_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_tempo_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_meter_marker_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_tempo_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_meter_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_range_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_transport_marker_bar_event (GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_imageframe_item_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_imageframe_view_event(GnomeCanvasItem *item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_imageframe_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_imageframe_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_marker_time_axis_view_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_markerview_item_view_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_markerview_start_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_markerview_end_handle_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
+ virtual gint _canvas_automation_track_event(GnomeCanvasItem* item, GdkEvent* event, gpointer data) = 0;
static PublicEditor* _instance;
};
using namespace ARDOUR;
RedirectAutomationLine::RedirectAutomationLine (string name, Redirect& rd, uint32_t port, Session& s,
- TimeAxisView& tv, GtkCanvasItem* parent,
+ TimeAxisView& tv, GnomeCanvasItem* parent,
AutomationList& l,
- gint (*point_callback)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_callback)(GtkCanvasItem*, GdkEvent*, gpointer))
+ gint (*point_callback)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_callback)(GnomeCanvasItem*, GdkEvent*, gpointer))
: AutomationLine (name, tv, parent, l, point_callback, line_callback),
session (s),
#define __ardour_gtk_redirect_automation_line_h__
#include <ardour/ardour.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <gtkmm.h>
#include "automation_line.h"
class RedirectAutomationLine : public AutomationLine
{
public:
- RedirectAutomationLine (string name, ARDOUR::Redirect&, uint32_t port, ARDOUR::Session&, TimeAxisView&, GtkCanvasItem* parent,
+ RedirectAutomationLine (string name, ARDOUR::Redirect&, uint32_t port, ARDOUR::Session&, TimeAxisView&, GnomeCanvasItem* parent,
ARDOUR::AutomationList&,
- gint (*point_callback)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_callback)(GtkCanvasItem*, GdkEvent*, gpointer));
+ gint (*point_callback)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_callback)(GnomeCanvasItem*, GdkEvent*, gpointer));
uint32_t port() const { return _port; }
ARDOUR::Redirect& redirect() const { return _redirect; }
}
void
-RedirectAutomationTimeAxisView::add_automation_event (GtkCanvasItem* item, GdkEvent* event, jack_nframes_t when, double y)
+RedirectAutomationTimeAxisView::add_automation_event (GnomeCanvasItem* item, GdkEvent* event, jack_nframes_t when, double y)
{
double x = 0;
- gtk_canvas_item_w2i (canvas_display, &x, &y);
+ gnome_canvas_item_w2i (canvas_display, &x, &y);
/* compute vertical fractional position */
~RedirectAutomationTimeAxisView();
- void add_automation_event (GtkCanvasItem *item, GdkEvent *event, jack_nframes_t, double);
+ void add_automation_event (GnomeCanvasItem *item, GdkEvent *event, jack_nframes_t, double);
guint32 show_at (double y, int& nth, Gtk::VBox *parent);
void hide ();
#include <map>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <sigc++/signal.h>
#include "audio_clock.h"
using namespace std;
using namespace ARDOUR;
-AudioRegionGainLine::AudioRegionGainLine (string name, Session& s, AudioRegionView& r, GtkCanvasItem* parent,
+AudioRegionGainLine::AudioRegionGainLine (string name, Session& s, AudioRegionView& r, GnomeCanvasItem* parent,
Curve& c,
- gint (*point_callback)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_callback)(GtkCanvasItem*, GdkEvent*, gpointer))
+ gint (*point_callback)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_callback)(GnomeCanvasItem*, GdkEvent*, gpointer))
: AutomationLine (name, r.get_time_axis_view(), parent, c, point_callback, line_callback),
session (s),
rv (r)
{
- gtk_canvas_item_raise_to_top (group);
+ gnome_canvas_item_raise_to_top (group);
set_verbose_cursor_uses_gain_mapping (true);
terminal_points_can_slide = false;
}
#define __ardour_gtk_region_gain_line_h__
#include <ardour/ardour.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <gtkmm.h>
#include "automation_line.h"
class AudioRegionGainLine : public AutomationLine
{
public:
- AudioRegionGainLine (string name, ARDOUR::Session&, AudioRegionView&, GtkCanvasItem* parent,
+ AudioRegionGainLine (string name, ARDOUR::Session&, AudioRegionView&, GnomeCanvasItem* parent,
ARDOUR::Curve&,
- gint (*point_callback)(GtkCanvasItem*, GdkEvent*, gpointer),
- gint (*line_callback)(GtkCanvasItem*, GdkEvent*, gpointer));
+ gint (*point_callback)(GnomeCanvasItem*, GdkEvent*, gpointer),
+ gint (*line_callback)(GnomeCanvasItem*, GdkEvent*, gpointer));
void view_to_model_y (double&);
void model_to_view_y (double&);
sigc::signal<void,AudioRegionView*> AudioRegionView::AudioRegionViewGoingAway;
-AudioRegionView::AudioRegionView (GtkCanvasGroup *parent, AudioTimeAxisView &tv,
+AudioRegionView::AudioRegionView (GnomeCanvasGroup *parent, AudioTimeAxisView &tv,
AudioRegion& r,
double spu,
double amplitude_above_axis,
region (r)
{
- GtkCanvasPoints *shape;
+ GnomeCanvasPoints *shape;
XMLNode *node;
editor = 0;
gtk_object_set_data (GTK_OBJECT(name_highlight), "regionview", this);
gtk_object_set_data (GTK_OBJECT(name_text), "regionview", this);
- shape = gtk_canvas_points_new (4);
+ shape = gnome_canvas_points_new (4);
/* an equilateral triangle */
shape->coords[7] = 1;
// cerr << "set sync mark al points, nc = " << shape->num_points << endl;
- sync_mark = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_polygon_get_type(),
+ sync_mark = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_polygon_get_type(),
"points", shape,
"fill_color_rgba", fill_color,
NULL);
- gtk_canvas_item_hide (sync_mark);
- gtk_canvas_points_unref (shape);
+ gnome_canvas_item_hide (sync_mark);
+ gnome_canvas_points_unref (shape);
- fade_in_shape = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_polygon_get_type(),
+ fade_in_shape = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_polygon_get_type(),
"fill_color_rgba", fade_color,
NULL);
gtk_object_set_data (GTK_OBJECT(fade_in_shape), "regionview", this);
- fade_out_shape = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_polygon_get_type(),
+ fade_out_shape = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_polygon_get_type(),
"fill_color_rgba", fade_color,
NULL);
gtk_object_set_data (GTK_OBJECT(fade_out_shape), "regionview", this);
UINT_TO_RGBA(fill_color,&r,&g,&b,&a);
- fade_in_handle = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
+ fade_in_handle = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simplerect_get_type(),
"fill_color_rgba", RGBA_TO_UINT(r,g,b,0),
"outline_pixels", 0,
"y1", 2.0,
NULL);
gtk_object_set_data (GTK_OBJECT(fade_in_handle), "regionview", this);
- fade_out_handle = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
+ fade_out_handle = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simplerect_get_type(),
"fill_color_rgba", RGBA_TO_UINT(r,g,b,0),
"outline_pixels", 0,
"y1", 2.0,
AudioRegionViewGoingAway (this); /* EMIT_SIGNAL */
- for (vector<GtkCanvasWaveViewCache *>::iterator cache = wave_caches.begin(); cache != wave_caches.end() ; ++cache) {
- gtk_canvas_waveview_cache_destroy (*cache);
+ for (vector<GnomeCanvasWaveViewCache *>::iterator cache = wave_caches.begin(); cache != wave_caches.end() ; ++cache) {
+ gnome_canvas_waveview_cache_destroy (*cache);
}
/* all waveviews will be destroyed when the group is destroyed */
}
gint
-AudioRegionView::_lock_toggle (GtkCanvasItem* item, GdkEvent* ev, void* arg)
+AudioRegionView::_lock_toggle (GnomeCanvasItem* item, GdkEvent* ev, void* arg)
{
switch (ev->type) {
case GDK_BUTTON_RELEASE:
if (region.fade_in_active()) {
col = RGBA_TO_UINT(r,g,b,120);
- gtk_canvas_item_set (fade_in_shape,
+ gnome_canvas_item_set (fade_in_shape,
"fill_color_rgba", col,
"width_pixels", 0,
"outline_color_rgba", RGBA_TO_UINT(r,g,b,0),
NULL);
} else {
col = RGBA_TO_UINT(r,g,b,0);
- gtk_canvas_item_set (fade_in_shape,
+ gnome_canvas_item_set (fade_in_shape,
"fill_color_rgba", col,
"width_pixels", 1,
"outline_color_rgba", RGBA_TO_UINT(r,g,b,255),
if (region.fade_out_active()) {
col = RGBA_TO_UINT(r,g,b,120);
- gtk_canvas_item_set (fade_out_shape,
+ gnome_canvas_item_set (fade_out_shape,
"fill_color_rgba", col,
"width_pixels", 0,
"outline_color_rgba", RGBA_TO_UINT(r,g,b,0),
NULL);
} else {
col = RGBA_TO_UINT(r,g,b,0);
- gtk_canvas_item_set (fade_out_shape,
+ gnome_canvas_item_set (fade_out_shape,
"fill_color_rgba", col,
"width_pixels", 1,
"outline_color_rgba", RGBA_TO_UINT(r,g,b,255),
for (uint32_t n = 0; n < waves.size(); ++n) {
// force a reload of the cache
- gtk_canvas_item_set (waves[n], "data_src", ®ion, NULL);
+ gnome_canvas_item_set (waves[n], "data_src", ®ion, NULL);
}
}
reset_width_dependent_items (unit_length);
for (uint32_t n = 0; n < waves.size(); ++n) {
- gtk_canvas_item_set (waves[n], "region_start", (guint32) region.start(), NULL);
+ gnome_canvas_item_set (waves[n], "region_start", (guint32) region.start(), NULL);
}
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
(*i)->set_duration (unit_length);
- for (vector<GtkCanvasItem*>::iterator w = (*i)->waves.begin(); w != (*i)->waves.end(); ++w) {
- gtk_canvas_item_set ((*w), "region_start", region.start(), NULL);
+ for (vector<GnomeCanvasItem*>::iterator w = (*i)->waves.begin(); w != (*i)->waves.end(); ++w) {
+ gnome_canvas_item_set ((*w), "region_start", region.start(), NULL);
}
}
}
_pixel_width = pixel_width;
if (zero_line) {
- gtk_canvas_item_set (zero_line, "x2", pixel_width - 1.0, NULL);
+ gnome_canvas_item_set (zero_line, "x2", pixel_width - 1.0, NULL);
}
if (pixel_width <= 6.0) {
- gtk_canvas_item_hide (fade_in_handle);
- gtk_canvas_item_hide (fade_out_handle);
+ gnome_canvas_item_hide (fade_in_handle);
+ gnome_canvas_item_hide (fade_out_handle);
} else {
if (_height < 5.0) {
- gtk_canvas_item_hide (fade_in_handle);
- gtk_canvas_item_hide (fade_out_handle);
+ gnome_canvas_item_hide (fade_in_handle);
+ gnome_canvas_item_hide (fade_out_handle);
} else {
- gtk_canvas_item_show (fade_in_handle);
- gtk_canvas_item_show (fade_out_handle);
+ gnome_canvas_item_show (fade_in_handle);
+ gnome_canvas_item_show (fade_out_handle);
}
}
for (uint32_t n=0; n < waves.size(); ++n) {
if (region.muted()) {
- gtk_canvas_item_set (waves[n], "wave_color", color_map[cMutedWaveForm], NULL);
+ gnome_canvas_item_set (waves[n], "wave_color", color_map[cMutedWaveForm], NULL);
} else {
- gtk_canvas_item_set (waves[n], "wave_color", color_map[cWaveForm], NULL);
+ gnome_canvas_item_set (waves[n], "wave_color", color_map[cWaveForm], NULL);
}
}
}
if (delta) {
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
- gtk_canvas_item_move ((*i)->group, delta, 0.0);
+ gnome_canvas_item_move ((*i)->group, delta, 0.0);
}
}
gdouble yoff = n * (ht+1);
- gtk_canvas_item_set (waves[n], "height", ht, NULL);
- gtk_canvas_item_set (waves[n], "y", yoff + 2, NULL);
+ gnome_canvas_item_set (waves[n], "height", ht, NULL);
+ gnome_canvas_item_set (waves[n], "y", yoff + 2, NULL);
}
if ((height/wcnt) < NAME_HIGHLIGHT_SIZE) {
gain_line->set_height ((uint32_t) rint (height - NAME_HIGHLIGHT_SIZE));
reset_fade_shapes ();
- gtk_canvas_item_raise_to_top (name_text) ;
+ gnome_canvas_item_raise_to_top (name_text) ;
}
void
if (_height >= 100) {
gdouble wave_midpoint = (_height - NAME_HIGHLIGHT_SIZE) / 2.0;
- gtk_canvas_item_set (zero_line,
+ gnome_canvas_item_set (zero_line,
"y1", wave_midpoint,
"y2", wave_midpoint,
NULL);
- gtk_canvas_item_show (zero_line);
+ gnome_canvas_item_show (zero_line);
} else {
- gtk_canvas_item_hide (zero_line);
+ gnome_canvas_item_hide (zero_line);
}
}
width = std::max ((jack_nframes_t) 64, width);
- GtkCanvasPoints* points;
+ GnomeCanvasPoints* points;
double pwidth = width / samples_per_unit;
uint32_t npoints = std::min (gdk_screen_width(), (int) pwidth);
double h;
if (_height < 5) {
- gtk_canvas_item_hide (fade_in_shape);
- gtk_canvas_item_hide (fade_in_handle);
+ gnome_canvas_item_hide (fade_in_shape);
+ gnome_canvas_item_hide (fade_in_handle);
return;
}
handle_center = 3.0;
}
- gtk_canvas_item_set (fade_in_handle,
+ gnome_canvas_item_set (fade_in_handle,
"x1", handle_center - 3.0,
"x2", handle_center + 3.0,
NULL);
if (pwidth < 5) {
- gtk_canvas_item_hide (fade_in_shape);
+ gnome_canvas_item_hide (fade_in_shape);
return;
}
- gtk_canvas_item_show (fade_in_shape);
+ gnome_canvas_item_show (fade_in_shape);
float curve[npoints];
region.fade_in().get_vector (0, region.fade_in().back()->when, curve, npoints);
points->coords[pi++] = points->coords[0];
points->coords[pi] = points->coords[1];
- gtk_canvas_item_set (fade_in_shape, "points", points, NULL);
- gtk_canvas_points_unref (points);
+ gnome_canvas_item_set (fade_in_shape, "points", points, NULL);
+ gnome_canvas_points_unref (points);
}
void
width = std::max ((jack_nframes_t) 64, width);
- GtkCanvasPoints* points;
+ GnomeCanvasPoints* points;
double pwidth = width / samples_per_unit;
uint32_t npoints = std::min (gdk_screen_width(), (int) pwidth);
double h;
if (_height < 5) {
- gtk_canvas_item_hide (fade_out_shape);
- gtk_canvas_item_hide (fade_out_handle);
+ gnome_canvas_item_hide (fade_out_shape);
+ gnome_canvas_item_hide (fade_out_handle);
return;
}
handle_center = 3.0;
}
- gtk_canvas_item_set (fade_out_handle,
+ gnome_canvas_item_set (fade_out_handle,
"x1", handle_center - 3.0,
"x2", handle_center + 3.0,
NULL);
/* don't show shape if its too small */
if (pwidth < 5) {
- gtk_canvas_item_hide (fade_out_shape);
+ gnome_canvas_item_hide (fade_out_shape);
return;
}
- gtk_canvas_item_show (fade_out_shape);
+ gnome_canvas_item_show (fade_out_shape);
float curve[npoints];
region.fade_out().get_vector (0, region.fade_out().back()->when, curve, npoints);
points->coords[pi++] = points->coords[0];
points->coords[pi] = points->coords[1];
- gtk_canvas_item_set (fade_out_shape, "points", points, NULL);
- gtk_canvas_points_unref (points);
+ gnome_canvas_item_set (fade_out_shape, "points", points, NULL);
+ gnome_canvas_points_unref (points);
}
void
TimeAxisViewItem::set_samples_per_unit (spu);
for (uint32_t n=0; n < waves.size(); ++n) {
- gtk_canvas_item_set (waves[n], "samples_per_unit", spu, NULL);
+ gnome_canvas_item_set (waves[n], "samples_per_unit", spu, NULL);
}
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
AudioRegionView::set_amplitude_above_axis (gdouble spp)
{
for (uint32_t n=0; n < waves.size(); ++n) {
- gtk_canvas_item_set (waves[n], "amplitude_above_axis", spp, NULL);
+ gnome_canvas_item_set (waves[n], "amplitude_above_axis", spp, NULL);
}
}
TimeAxisViewItem::set_colors ();
gain_line->set_line_color (region.envelope_active() ? color_map[cGainLine] : color_map[cGainLineInactive]);
- gtk_canvas_item_set (sync_mark, "fill_color_rgba", fill_color, NULL);
+ gnome_canvas_item_set (sync_mark, "fill_color_rgba", fill_color, NULL);
for (uint32_t n=0; n < waves.size(); ++n) {
if (region.muted()) {
- gtk_canvas_item_set (waves[n], "wave_color", color_map[cMutedWaveForm], NULL);
+ gnome_canvas_item_set (waves[n], "wave_color", color_map[cMutedWaveForm], NULL);
} else {
- gtk_canvas_item_set (waves[n], "wave_color", color_map[cWaveForm], NULL);
+ gnome_canvas_item_set (waves[n], "wave_color", color_map[cWaveForm], NULL);
}
}
}
/* no sync mark - its the start of the region */
- gtk_canvas_item_hide (sync_mark);
+ gnome_canvas_item_hide (sync_mark);
} else {
/* no sync mark - its out of the bounds of the region */
- gtk_canvas_item_hide (sync_mark);
+ gnome_canvas_item_hide (sync_mark);
} else {
/* lets do it */
GtkArg args[1];
- GtkCanvasPoints* points;
+ GnomeCanvasPoints* points;
args[0].name = X_("points");
gtk_object_getv (GTK_OBJECT(sync_mark), 1, args);
- points = static_cast<GtkCanvasPoints *> (GTK_VALUE_POINTER(args[0]));
+ points = static_cast<GnomeCanvasPoints *> (GTK_VALUE_POINTER(args[0]));
double offset = sync_offset / samples_per_unit;
points->coords[6] = offset - ((sync_mark_width-1)/2);
points->coords[7] = 1;
- gtk_canvas_item_show (sync_mark);
- gtk_canvas_item_set (sync_mark, "points", points, NULL);
+ gnome_canvas_item_show (sync_mark);
+ gnome_canvas_item_set (sync_mark, "points", points, NULL);
- gtk_canvas_points_unref (points);
+ gnome_canvas_points_unref (points);
}
}
}
if (((_flags & WaveformVisible) != yn)) {
if (yn) {
for (uint32_t n=0; n < waves.size(); ++n) {
- gtk_canvas_item_show (waves[n]);
+ gnome_canvas_item_show (waves[n]);
}
_flags |= WaveformVisible;
} else {
for (uint32_t n=0; n < waves.size(); ++n) {
- gtk_canvas_item_hide (waves[n]);
+ gnome_canvas_item_hide (waves[n]);
}
_flags &= ~WaveformVisible;
}
break;
}
- wave_caches.push_back (gtk_canvas_waveview_cache_new ());
+ wave_caches.push_back (gnome_canvas_waveview_cache_new ());
if (wait_for_waves) {
if (region.source(n).peaks_ready (bind (mem_fun(*this, &AudioRegionView::peaks_ready_handler), n))) {
}
if (create_zero_line) {
- zero_line = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_simpleline_get_type(),
+ zero_line = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simpleline_get_type(),
"x1", (gdouble) 1.0,
"x2", (gdouble) (region.length() / samples_per_unit) - 1.0,
"color_rgba", (guint) color_map[cZeroLine],
}
gdouble yoff = which * ht;
- GtkCanvasItem *wave = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_waveview_get_type (),
+ GnomeCanvasItem *wave = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_waveview_get_type (),
"data_src", (gpointer) ®ion,
"cache", wave_caches[which],
"cache_updater", (gboolean) true,
NULL);
if (!(_flags & WaveformVisible)) {
- gtk_canvas_item_hide (wave);
+ gnome_canvas_item_hide (wave);
}
/* note: calling this function is serialized by the lock
tmp_waves.clear ();
if (!zero_line) {
- zero_line = gtk_canvas_item_new (GTK_CANVAS_GROUP(group),
- gtk_canvas_simpleline_get_type(),
+ zero_line = gnome_canvas_item_new (GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simpleline_get_type(),
"x1", (gdouble) 1.0,
"x2", (gdouble) (region.length() / samples_per_unit) - 1.0,
"color_rgba", (guint) color_map[cZeroLine],
}
void
-AudioRegionView::add_gain_point_event (GtkCanvasItem *item, GdkEvent *ev)
+AudioRegionView::add_gain_point_event (GnomeCanvasItem *item, GdkEvent *ev)
{
double x, y;
x = ev->button.x;
y = ev->button.y;
- gtk_canvas_item_w2i (item, &x, &y);
+ gnome_canvas_item_w2i (item, &x, &y);
jack_nframes_t fx = trackview.editor.pixel_to_frame (x);
}
void
-AudioRegionView::remove_gain_point_event (GtkCanvasItem *item, GdkEvent *ev)
+AudioRegionView::remove_gain_point_event (GnomeCanvasItem *item, GdkEvent *ev)
{
ControlPoint *cp = reinterpret_cast<ControlPoint *> (gtk_object_get_data(GTK_OBJECT(item), "control_point"));
region.envelope().erase (cp->model);
}
if (yn != (bool) (_flags & WaveformRectified)) {
- for (vector<GtkCanvasItem *>::iterator wave = waves.begin(); wave != waves.end() ; ++wave) {
- gtk_canvas_item_set ((*wave), "rectified", (gboolean) yn, NULL);
+ for (vector<GnomeCanvasItem *>::iterator wave = waves.begin(); wave != waves.end() ; ++wave) {
+ gnome_canvas_item_set ((*wave), "rectified", (gboolean) yn, NULL);
}
if (zero_line) {
if (yn) {
- gtk_canvas_item_hide (zero_line);
+ gnome_canvas_item_hide (zero_line);
} else {
- gtk_canvas_item_show (zero_line);
+ gnome_canvas_item_show (zero_line);
}
}
return;
}
- gtk_canvas_item_move (get_canvas_group(), x_delta, y_delta);
+ gnome_canvas_item_move (get_canvas_group(), x_delta, y_delta);
/* note: ghosts never leave their tracks so y_delta for them is always zero */
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
- gtk_canvas_item_move ((*i)->group, x_delta, 0.0);
+ gnome_canvas_item_move ((*i)->group, x_delta, 0.0);
}
}
break;
}
- GtkCanvasItem *wave = gtk_canvas_item_new (GTK_CANVAS_GROUP(ghost->group),
- gtk_canvas_waveview_get_type (),
+ GnomeCanvasItem *wave = gnome_canvas_item_new (GNOME_CANVAS_GROUP(ghost->group),
+ gnome_canvas_waveview_get_type (),
"data_src", (gpointer) ®ion,
"cache", wave_caches[n],
"cache_updater", (gboolean) false,
UINT_TO_RGBA(fade_color,&r,&g,&b,&a);
a=255;
- gtk_canvas_item_set (fade_in_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
- gtk_canvas_item_set (fade_out_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
+ gnome_canvas_item_set (fade_in_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
+ gnome_canvas_item_set (fade_out_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
}
void
UINT_TO_RGBA(fade_color,&r,&g,&b,&a);
a=0;
- gtk_canvas_item_set (fade_in_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
- gtk_canvas_item_set (fade_out_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
+ gnome_canvas_item_set (fade_in_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
+ gnome_canvas_item_set (fade_out_handle, "fill_color_rgba", RGBA_TO_UINT(r,g,b,a), NULL);
}
void
for (uint32_t n = 0; n < waves.size(); ++n) {
// TODO: something else to let it know the channel
- gtk_canvas_item_set (waves[n], "data_src", ®ion, NULL);
+ gnome_canvas_item_set (waves[n], "data_src", ®ion, NULL);
}
for (vector<GhostRegion*>::iterator i = ghosts.begin(); i != ghosts.end(); ++i) {
(*i)->set_duration (unit_length);
- for (vector<GtkCanvasItem*>::iterator w = (*i)->waves.begin(); w != (*i)->waves.end(); ++w) {
- gtk_canvas_item_set ((*w), "data_src", ®ion, NULL);
+ for (vector<GnomeCanvasItem*>::iterator w = (*i)->waves.begin(); w != (*i)->waves.end(); ++w) {
+ gnome_canvas_item_set ((*w), "data_src", ®ion, NULL);
}
}
#include <vector>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <sigc++/signal.h>
#include <ardour/region.h>
class AudioRegionView : public TimeAxisViewItem
{
public:
- AudioRegionView (GtkCanvasGroup *,
+ AudioRegionView (GnomeCanvasGroup *,
AudioTimeAxisView&,
ARDOUR::AudioRegion&,
double initial_samples_per_unit,
void show_region_editor ();
void hide_region_editor();
- void add_gain_point_event (GtkCanvasItem *item, GdkEvent *event);
- void remove_gain_point_event (GtkCanvasItem *item, GdkEvent *event);
+ void add_gain_point_event (GnomeCanvasItem *item, GdkEvent *event);
+ void remove_gain_point_event (GnomeCanvasItem *item, GdkEvent *event);
AudioRegionGainLine* get_gain_line() const { return gain_line; }
WaveformRectified = 0x8
};
- vector<GtkCanvasItem *> waves; /* waveviews */
- vector<GtkCanvasItem *> tmp_waves; /* see ::create_waves()*/
- GtkCanvasItem* sync_mark; /* polgyon for sync position */
- GtkCanvasItem* no_wave_msg; /* text */
- GtkCanvasItem* zero_line; /* simpleline */
- GtkCanvasItem* fade_in_shape; /* polygon */
- GtkCanvasItem* fade_out_shape; /* polygon */
- GtkCanvasItem* fade_in_handle; /* simplerect */
- GtkCanvasItem* fade_out_handle; /* simplerect */
+ vector<GnomeCanvasItem *> waves; /* waveviews */
+ vector<GnomeCanvasItem *> tmp_waves; /* see ::create_waves()*/
+ GnomeCanvasItem* sync_mark; /* polgyon for sync position */
+ GnomeCanvasItem* no_wave_msg; /* text */
+ GnomeCanvasItem* zero_line; /* simpleline */
+ GnomeCanvasItem* fade_in_shape; /* polygon */
+ GnomeCanvasItem* fade_out_shape; /* polygon */
+ GnomeCanvasItem* fade_in_handle; /* simplerect */
+ GnomeCanvasItem* fade_out_handle; /* simplerect */
AudioRegionGainLine* gain_line;
AudioRegionEditor *editor;
void region_sync_changed ();
void region_scale_amplitude_changed ();
- static gint _lock_toggle (GtkCanvasItem*, GdkEvent*, void*);
+ static gint _lock_toggle (GnomeCanvasItem*, GdkEvent*, void*);
void lock_toggle ();
void create_waves ();
void reset_width_dependent_items (double pixel_width);
void set_waveview_data_src();
- vector<GtkCanvasWaveViewCache*> wave_caches;
+ vector<GnomeCanvasWaveViewCache*> wave_caches;
vector<GhostRegion*> ghosts;
};
}
#define PAINT_HORIZ(inbuf, colr, colg, colb, ptx0, ptx1, pty) \
{ \
- GtkCanvasBuf* ph_buf = (inbuf); \
+ GnomeCanvasBuf* ph_buf = (inbuf); \
guchar* ph_p; \
gint ph_a0, ph_a1; \
gint ph_colr=(colr), ph_colg=(colg), ph_colb=(colb); \
}
#define FAST_PAINT_HORIZ(inbuf, colr, colg, colb, ptx0, ptx1, pty) \
{ \
- GtkCanvasBuf* ph_buf = (inbuf); \
+ GnomeCanvasBuf* ph_buf = (inbuf); \
guchar* ph_p; \
gint ph_a0, ph_a1; \
gint ph_colr=(colr), ph_colg=(colg), ph_colb=(colb); \
}
#define PAINT_HORIZA(inbuf, colr, colg, colb, cola, ptx0, ptx1, pty) \
{ \
- GtkCanvasBuf* ph_buf = (inbuf); \
+ GnomeCanvasBuf* ph_buf = (inbuf); \
guchar* ph_p; \
gint ph_a0, ph_a1; \
gint ph_colr=(colr), ph_colg=(colg), ph_colb=(colb), ph_cola=(cola); \
}
#define PAINT_VERT(inbuf, colr, colg, colb, ptx, pty0, pty1) \
{ \
- GtkCanvasBuf* pv_buf = (inbuf); \
+ GnomeCanvasBuf* pv_buf = (inbuf); \
guchar* pv_p; \
gint pv_b0, pv_b1; \
gint pv_colr=(colr), pv_colg=(colg), pv_colb=(colb);\
}
#define FAST_PAINT_VERT(inbuf, colr, colg, colb, ptx, pty0, pty1) \
{ \
- GtkCanvasBuf* fpv_buf = (inbuf); \
+ GnomeCanvasBuf* fpv_buf = (inbuf); \
guchar* fpv_p; \
gint fpv_b0, fpv_b1; \
\
}
#define PAINT_VERTA(inbuf, colr, colg, colb, cola, ptx, pty0, pty1) \
{ \
- GtkCanvasBuf* pv_buf = (inbuf); \
+ GnomeCanvasBuf* pv_buf = (inbuf); \
guchar* pv_p; \
gint pv_b0, pv_b1; \
gint pv_colr=(colr), pv_colg=(colg), pv_colb=(colb), pv_cola=(cola);\
} \
}
-/* Paint a solid-colored box into a GtkCanvasBuf (clipping as necessary).
+/* Paint a solid-colored box into a GnomeCanvasBuf (clipping as necessary).
The box contains (ptx0,pty0), but not (ptx1, pty1).
Each macro arg should appear exactly once in the body of the code. */
#define PAINT_BOX(inbuf, colr, colg, colb, cola, ptx0, pty0, ptx1, pty1) \
{ \
- GtkCanvasBuf* pb_buf = (inbuf); \
+ GnomeCanvasBuf* pb_buf = (inbuf); \
guchar* pb_p; \
guchar* pb_pp; \
gint pb_a0, pb_a1, pb_b0, pb_b1, pb_i, pb_j; \
#define FAST_PAINT_BOX(inbuf, colr, colg, colb, cola, ptx0, pty0, ptx1, pty1) \
{ \
- GtkCanvasBuf* pb_buf = (inbuf); \
+ GnomeCanvasBuf* pb_buf = (inbuf); \
guchar* pb_p; \
guchar* pb_pp; \
gint pb_i, pb_j; \
/* set_position() will position the group */
- canvas_group = gtk_canvas_item_new (GTK_CANVAS_GROUP(_trackview.canvas_display),
- gtk_canvas_group_get_type (),
+ canvas_group = gnome_canvas_item_new (GNOME_CANVAS_GROUP(_trackview.canvas_display),
+ gnome_canvas_group_get_type (),
NULL);
- canvas_rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(canvas_group),
- gtk_canvas_simplerect_get_type(),
+ canvas_rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(canvas_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 1000000.0,
StreamView::set_position (gdouble x, gdouble y)
{
- gtk_canvas_item_set (canvas_group, "x", x, "y", y, NULL);
+ gnome_canvas_item_set (canvas_group, "x", x, "y", y, NULL);
return 0;
}
gdouble xstart = _trackview.editor.frame_to_pixel ( recbox.start );
gdouble xend = _trackview.editor.frame_to_pixel ( recbox.start + recbox.length );
- gtk_canvas_item_set (recbox.rectangle, "x1", xstart, NULL);
- gtk_canvas_item_set (recbox.rectangle, "x2", xend, NULL);
+ gnome_canvas_item_set (recbox.rectangle, "x1", xstart, NULL);
+ gnome_canvas_item_set (recbox.rectangle, "x2", xend, NULL);
}
return 0;
}
}
- region_view = new AudioRegionView (GTK_CANVAS_GROUP(canvas_group),
+ region_view = new AudioRegionView (GNOME_CANVAS_GROUP(canvas_group),
_trackview,
*region,
_samples_per_unit,
}
for (list<CrossfadeView *>::iterator i = crossfade_views.begin(); i != crossfade_views.end(); ++i) {
- gtk_canvas_item_raise_to_top ((*i)->get_canvas_group());
+ gnome_canvas_item_raise_to_top ((*i)->get_canvas_group());
}
}
}
}
- CrossfadeView *cv = new CrossfadeView (GTK_CANVAS_GROUP(_trackview.canvas_display),
+ CrossfadeView *cv = new CrossfadeView (GNOME_CANVAS_GROUP(_trackview.canvas_display),
_trackview,
*crossfade,
_samples_per_unit,
(*i)->set_color (region_color);
}
// stream_base_color = RGBA_TO_UINT (color.red/256, color.green/256, color.blue/256, 255);
- // gtk_canvas_item_set (canvas_rect, "fill_color_rgba", stream_base_color, NULL);
+ // gnome_canvas_item_set (canvas_rect, "fill_color_rgba", stream_base_color, NULL);
break;
case StreamBaseColor:
// stream_base_color = RGBA_TO_UINT (color.red/256, color.green/256, color.blue/256, 255);
- // gtk_canvas_item_set (canvas_rect, "fill_color_rgba", stream_base_color, NULL);
+ // gnome_canvas_item_set (canvas_rect, "fill_color_rgba", stream_base_color, NULL);
break;
}
}
void
StreamView::region_layered (AudioRegionView* rv)
{
- gtk_canvas_item_lower_to_bottom (rv->get_canvas_group());
+ gnome_canvas_item_lower_to_bottom (rv->get_canvas_group());
/* don't ever leave it at the bottom, since then it doesn't
get events - the parent group does instead ...
*/
- gtk_canvas_item_raise (rv->get_canvas_group(), rv->region.layer() + 1);
+ gnome_canvas_item_raise (rv->get_canvas_group(), rv->region.layer() + 1);
}
void
gdouble xstart = _trackview.editor.frame_to_pixel (frame_pos);
gdouble xend = xstart;
- GtkCanvasItem * rec_rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(canvas_group),
- gtk_canvas_simplerect_get_type(),
+ GnomeCanvasItem * rec_rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(canvas_group),
+ gnome_canvas_simplerect_get_type(),
"x1", xstart,
"y1", 1.0,
"x2", xend,
gdouble xstart = _trackview.editor.frame_to_pixel ( rect.start );
gdouble xend = _trackview.editor.frame_to_pixel ( at );
- gtk_canvas_item_set (rect.rectangle, "x1", xstart, NULL);
- gtk_canvas_item_set (rect.rectangle, "x2", xend, NULL);
+ gnome_canvas_item_set (rect.rectangle, "x1", xstart, NULL);
+ gnome_canvas_item_set (rect.rectangle, "x2", xend, NULL);
}
}
tmp = iter;
++tmp;
- if ((GTK_OBJECT_FLAGS(GTK_OBJECT(rec_rects[n].rectangle)) & GTK_CANVAS_ITEM_VISIBLE) == 0) {
+ if ((GTK_OBJECT_FLAGS(GTK_OBJECT(rec_rects[n].rectangle)) & GNOME_CANVAS_ITEM_VISIBLE) == 0) {
/* rect already hidden, this region is done */
iter = tmp;
continue;
}
/* also update rect */
- GtkCanvasItem * rect = rec_rects[n].rectangle;
+ GnomeCanvasItem * rect = rec_rects[n].rectangle;
gdouble xend = _trackview.editor.frame_to_pixel (region->position() + region->length());
- gtk_canvas_item_set (rect, "x2", xend, NULL);
+ gnome_canvas_item_set (rect, "x2", xend, NULL);
}
}
}
/* also hide rect */
- GtkCanvasItem * rect = rec_rects[n].rectangle;
- gtk_canvas_item_hide (rect);
+ GnomeCanvasItem * rect = rec_rects[n].rectangle;
+ gnome_canvas_item_hide (rect);
}
}
#include <cmath>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <ardour/location.h>
#include "enums.h"
}
struct RecBoxInfo {
- GtkCanvasItem* rectangle;
+ GnomeCanvasItem* rectangle;
jack_nframes_t start;
jack_nframes_t length;
};
void set_show_waveforms (bool yn);
void set_show_waveforms_recording (bool yn) { use_rec_regions = yn; }
- GtkCanvasItem* canvas_item() { return canvas_group; }
+ GnomeCanvasItem* canvas_item() { return canvas_group; }
sigc::signal<void,AudioRegionView*> AudioRegionViewAdded;
private:
AudioTimeAxisView& _trackview;
- GtkCanvasItem* canvas_group;
- GtkCanvasItem* canvas_rect; /* frame around the whole thing */
+ GnomeCanvasItem* canvas_group;
+ GnomeCanvasItem* canvas_rect; /* frame around the whole thing */
typedef list<AudioRegionView* > AudioRegionViewList;
AudioRegionViewList region_views;
editor(ed),
controls_table (2, 9)
{
- canvas_display = gtk_canvas_item_new (gtk_canvas_root(GTK_CANVAS(canvas->gobj())),
- gtk_canvas_group_get_type(),
+ canvas_display = gnome_canvas_item_new (gnome_canvas_root(GNOME_CANVAS(canvas->gobj())),
+ gnome_canvas_group_get_type(),
"x", 0.0,
"y", 0.0,
NULL);
- selection_group = gtk_canvas_item_new (GTK_CANVAS_GROUP(canvas_display),
- gtk_canvas_group_get_type (),
+ selection_group = gnome_canvas_item_new (GNOME_CANVAS_GROUP(canvas_display),
+ gnome_canvas_group_get_type (),
NULL);
- gtk_canvas_item_hide (selection_group);
+ gnome_canvas_item_hide (selection_group);
control_parent = 0;
display_menu = 0;
item's parent ...
*/
- gtk_canvas_item_get_bounds (canvas_display, &ix1, &iy1, &ix2, &iy2);
- gtk_canvas_item_i2w (canvas_display->parent, &ix1, &iy1);
+ gnome_canvas_item_get_bounds (canvas_display, &ix1, &iy1, &ix2, &iy2);
+ gnome_canvas_item_i2w (canvas_display->parent, &ix1, &iy1);
if (iy1 < 0) {
iy1 = 0;
}
- gtk_canvas_item_move (canvas_display, 0.0, y - iy1);
- gtk_canvas_item_show (canvas_display); /* XXX not necessary */
+ gnome_canvas_item_move (canvas_display, 0.0, y - iy1);
+ gnome_canvas_item_show (canvas_display); /* XXX not necessary */
y_position = y;
order = nth;
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
if ((*i)->marked_for_display()) {
- gtk_canvas_item_show ((*i)->canvas_display);
+ gnome_canvas_item_show ((*i)->canvas_display);
}
- if (GTK_OBJECT_FLAGS(GTK_OBJECT((*i)->canvas_display)) & GTK_CANVAS_ITEM_VISIBLE) {
+ if (GTK_OBJECT_FLAGS(GTK_OBJECT((*i)->canvas_display)) & GNOME_CANVAS_ITEM_VISIBLE) {
++nth;
effective_height += (*i)->show_at (y + effective_height, nth, parent);
}
return;
}
- gtk_canvas_item_hide (canvas_display);
+ gnome_canvas_item_hide (canvas_display);
controls_frame.hide ();
if (control_parent) {
height = (guint32) h;
controls_frame.set_size_request (-1, height);
- if (GTK_OBJECT_FLAGS(GTK_OBJECT(selection_group)) & GTK_CANVAS_ITEM_VISIBLE) {
+ if (GTK_OBJECT_FLAGS(GTK_OBJECT(selection_group)) & GNOME_CANVAS_ITEM_VISIBLE) {
/* resize the selection rect */
show_selection (editor.get_selection().time);
}
(*i)->show_selection (ts);
}
- if (GTK_OBJECT_FLAGS(GTK_OBJECT(selection_group)) & GTK_CANVAS_ITEM_VISIBLE) {
+ if (GTK_OBJECT_FLAGS(GTK_OBJECT(selection_group)) & GNOME_CANVAS_ITEM_VISIBLE) {
while (!used_selection_rects.empty()) {
free_selection_rects.push_front (used_selection_rects.front());
used_selection_rects.pop_front();
- gtk_canvas_item_hide (free_selection_rects.front()->rect);
- gtk_canvas_item_hide (free_selection_rects.front()->start_trim);
- gtk_canvas_item_hide (free_selection_rects.front()->end_trim);
+ gnome_canvas_item_hide (free_selection_rects.front()->rect);
+ gnome_canvas_item_hide (free_selection_rects.front()->start_trim);
+ gnome_canvas_item_hide (free_selection_rects.front()->end_trim);
}
- gtk_canvas_item_hide (selection_group);
+ gnome_canvas_item_hide (selection_group);
}
- gtk_canvas_item_show (selection_group);
- gtk_canvas_item_raise_to_top (selection_group);
+ gnome_canvas_item_show (selection_group);
+ gnome_canvas_item_raise_to_top (selection_group);
for (list<AudioRange>::iterator i = ts.begin(); i != ts.end(); ++i) {
jack_nframes_t start, end, cnt;
"x2", x2,
"y2", 1.0 + trim_handle_size,
NULL);
- gtk_canvas_item_show (rect->start_trim);
- gtk_canvas_item_show (rect->end_trim);
+ gnome_canvas_item_show (rect->start_trim);
+ gnome_canvas_item_show (rect->end_trim);
} else {
- gtk_canvas_item_hide (rect->start_trim);
- gtk_canvas_item_hide (rect->end_trim);
+ gnome_canvas_item_hide (rect->start_trim);
+ gnome_canvas_item_hide (rect->end_trim);
}
- gtk_canvas_item_show (rect->rect);
+ gnome_canvas_item_show (rect->rect);
used_selection_rects.push_back (rect);
}
}
void
TimeAxisView::hide_selection ()
{
- if (GTK_OBJECT_FLAGS(GTK_OBJECT(selection_group)) & GTK_CANVAS_ITEM_VISIBLE) {
+ if (GTK_OBJECT_FLAGS(GTK_OBJECT(selection_group)) & GNOME_CANVAS_ITEM_VISIBLE) {
while (!used_selection_rects.empty()) {
free_selection_rects.push_front (used_selection_rects.front());
used_selection_rects.pop_front();
- gtk_canvas_item_hide (free_selection_rects.front()->rect);
- gtk_canvas_item_hide (free_selection_rects.front()->start_trim);
- gtk_canvas_item_hide (free_selection_rects.front()->end_trim);
+ gnome_canvas_item_hide (free_selection_rects.front()->rect);
+ gnome_canvas_item_hide (free_selection_rects.front()->start_trim);
+ gnome_canvas_item_hide (free_selection_rects.front()->end_trim);
}
- gtk_canvas_item_hide (selection_group);
+ gnome_canvas_item_hide (selection_group);
}
for (vector<TimeAxisView*>::iterator i = children.begin(); i != children.end(); ++i) {
}
void
-TimeAxisView::order_selection_trims (GtkCanvasItem *item, bool put_start_on_top)
+TimeAxisView::order_selection_trims (GnomeCanvasItem *item, bool put_start_on_top)
{
/* find the selection rect this is for. we have the item corresponding to one
of the trim handles.
the top one is the one last used.
*/
- gtk_canvas_item_raise_to_top ((*i)->rect);
- gtk_canvas_item_raise_to_top (put_start_on_top ? (*i)->start_trim : (*i)->end_trim);
- gtk_canvas_item_raise_to_top (put_start_on_top ? (*i)->end_trim : (*i)->start_trim);
+ gnome_canvas_item_raise_to_top ((*i)->rect);
+ gnome_canvas_item_raise_to_top (put_start_on_top ? (*i)->start_trim : (*i)->end_trim);
+ gnome_canvas_item_raise_to_top (put_start_on_top ? (*i)->end_trim : (*i)->start_trim);
break;
}
rect = new SelectionRect;
- rect->rect = gtk_canvas_item_new (GTK_CANVAS_GROUP(selection_group),
- gtk_canvas_simplerect_get_type(),
+ rect->rect = gnome_canvas_item_new (GNOME_CANVAS_GROUP(selection_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"y1", 0.0,
"x2", 0.0,
NULL);
- rect->start_trim = gtk_canvas_item_new (GTK_CANVAS_GROUP(selection_group),
- gtk_canvas_simplerect_get_type(),
+ rect->start_trim = gnome_canvas_item_new (GNOME_CANVAS_GROUP(selection_group),
+ gnome_canvas_simplerect_get_type(),
"x1", (gdouble) 0.0,
"x2", (gdouble) 0.0,
"fill_color_rgba" , color_map[cSelectionStartFill],
"outline_color_rgba" , color_map[cSelectionStartOutline],
NULL);
- rect->end_trim = gtk_canvas_item_new (GTK_CANVAS_GROUP(selection_group),
- gtk_canvas_simplerect_get_type(),
+ rect->end_trim = gnome_canvas_item_new (GNOME_CANVAS_GROUP(selection_group),
+ gnome_canvas_simplerect_get_type(),
"x1", 0.0,
"x2", 0.0,
"fill_color_rgba" , color_map[cSelectionEndFill],
#include <list>
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <ardour/types.h>
#include <ardour/region.h>
int order;
- GtkCanvasItem *canvas_display;
+ GnomeCanvasItem *canvas_display;
Gtk::VBox *control_parent;
/* The Standard LHS Controls */
return 0;
}
- void order_selection_trims (GtkCanvasItem *item, bool put_start_on_top);
+ void order_selection_trims (GnomeCanvasItem *item, bool put_start_on_top);
virtual void get_selectables (jack_nframes_t start, jack_nframes_t end, double top, double bot, list<Selectable*>& results);
virtual void get_inverted_selectables (Selection&, list<Selectable *>& results);
/* selection display */
- GtkCanvasItem *selection_group;
+ GnomeCanvasItem *selection_group;
list<SelectionRect*> free_selection_rects;
list<SelectionRect*> used_selection_rects;
* @param start the start point of this item
* @param duration the duration of this item
*/
-TimeAxisViewItem::TimeAxisViewItem(std::string it_name, GtkCanvasGroup* parent, TimeAxisView& tv, double spu, GdkColor& base_color,
+TimeAxisViewItem::TimeAxisViewItem(std::string it_name, GnomeCanvasGroup* parent, TimeAxisView& tv, double spu, GdkColor& base_color,
jack_nframes_t start, jack_nframes_t duration,
Visibility visibility)
: trackview (tv)
warning << "Time Axis Item Duration == 0" << endl ;
}
- group = gtk_canvas_item_new(GTK_CANVAS_GROUP(parent),gtk_canvas_group_get_type(),NULL) ;
+ group = gnome_canvas_item_new(GNOME_CANVAS_GROUP(parent),gnome_canvas_group_get_type(),NULL) ;
- vestigial_frame = gtk_canvas_item_new(GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
+ vestigial_frame = gnome_canvas_item_new(GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simplerect_get_type(),
"x1", (double) 0.0,
"y1", (double) 1.0,
"x2", 2.0,
"outline_color_rgba", color_map[cVestigialFrameOutline],
"fill_color_rgba", color_map[cVestigialFrameFill],
NULL);
- gtk_canvas_item_hide (vestigial_frame);
+ gnome_canvas_item_hide (vestigial_frame);
if (visibility & ShowFrame) {
- frame = gtk_canvas_item_new(GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
+ frame = gnome_canvas_item_new(GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simplerect_get_type(),
"x1", (double) 0.0,
"y1", (double) 1.0,
"x2", (double) trackview.editor.frame_to_pixel(duration),
}
if (visibility & ShowNameHighlight) {
- name_highlight = gtk_canvas_item_new(GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
+ name_highlight = gnome_canvas_item_new(GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simplerect_get_type(),
"x1", (double) 1.0,
"x2", (double) (trackview.editor.frame_to_pixel(item_duration)) - 1,
"y1", (double) (trackview.height - TimeAxisViewItem::NAME_HIGHLIGHT_SIZE),
}
if (visibility & ShowNameText) {
- name_text = gtk_canvas_item_new(GTK_CANVAS_GROUP(group),
- gtk_canvas_text_get_type(),
+ name_text = gnome_canvas_item_new(GNOME_CANVAS_GROUP(group),
+ gnome_canvas_text_get_type(),
"x", (double) TimeAxisViewItem::NAME_X_OFFSET,
"y", (double) trackview.height + 1.0 - TimeAxisViewItem::NAME_Y_OFFSET,
"font", NAME_FONT.c_str(),
/* create our grab handles used for trimming/duration etc */
if (visibility & ShowHandles) {
- frame_handle_start = gtk_canvas_item_new(GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
+ frame_handle_start = gnome_canvas_item_new(GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simplerect_get_type(),
"x1", (double) 0.0,
"x2", (double) TimeAxisViewItem::GRAB_HANDLE_LENGTH,
"y1", (double) 1.0,
"fill_color_rgba", color_map[cFrameHandleStartFill],
NULL) ;
- frame_handle_end = gtk_canvas_item_new(GTK_CANVAS_GROUP(group),
- gtk_canvas_simplerect_get_type(),
+ frame_handle_end = gnome_canvas_item_new(GNOME_CANVAS_GROUP(group),
+ gnome_canvas_simplerect_get_type(),
"x1", (double) (trackview.editor.frame_to_pixel(get_duration())) - (TimeAxisViewItem::GRAB_HANDLE_LENGTH),
"x2", (double) trackview.editor.frame_to_pixel(get_duration()),
"y1", (double) 1,
frame_position = pos;
- /* This sucks. The GtkCanvas version I am using
- doesn't correctly implement gtk_canvas_group_set_arg(),
+ /* This sucks. The GnomeCanvas version I am using
+ doesn't correctly implement gnome_canvas_group_set_arg(),
so that simply setting the "x" arg of the group
fails to move the group. Instead, we have to
- use gtk_canvas_item_move(), which does the right
+ use gnome_canvas_item_move(), which does the right
thing. I see that in GNOME CVS, the current (Sept 2001)
version of GNOME Canvas rectifies this issue cleanly.
*/
old_unit_pos = GTK_VALUE_DOUBLE (args[0]) ;
if (new_unit_pos != old_unit_pos) {
- gtk_canvas_item_move (group, new_unit_pos - old_unit_pos, 0.0) ;
+ gnome_canvas_item_move (group, new_unit_pos - old_unit_pos, 0.0) ;
}
if (delta) {
}
if (dur == 0) {
- gtk_canvas_item_hide (group);
+ gnome_canvas_item_hide (group);
}
item_duration = dur;
TimeAxisViewItem::set_name_text(std::string new_name)
{
if (name_text) {
- gtk_canvas_item_set (name_text, "text", new_name.c_str(), NULL);
+ gnome_canvas_item_set (name_text, "text", new_name.c_str(), NULL);
}
}
{
if (name_highlight) {
if (height < NAME_HIGHLIGHT_THRESH) {
- gtk_canvas_item_hide (name_highlight);
- gtk_canvas_item_hide (name_text);
+ gnome_canvas_item_hide (name_highlight);
+ gnome_canvas_item_hide (name_text);
} else {
- gtk_canvas_item_show (name_highlight);
- gtk_canvas_item_show (name_text);
+ gnome_canvas_item_show (name_highlight);
+ gnome_canvas_item_show (name_text);
}
if (height > NAME_HIGHLIGHT_SIZE) {
- gtk_canvas_item_set (name_highlight,
+ gnome_canvas_item_set (name_highlight,
"y1", (double) height+1 - NAME_HIGHLIGHT_SIZE,
"y2", (double) height,
NULL);
}
else {
/* it gets hidden now anyway */
- gtk_canvas_item_set (name_highlight,
+ gnome_canvas_item_set (name_highlight,
"y1", (double) 1.0,
"y2", (double) height,
NULL);
}
if (name_text) {
- gtk_canvas_item_set (name_text, "y", height+1 - NAME_Y_OFFSET, NULL);
+ gnome_canvas_item_set (name_text, "y", height+1 - NAME_Y_OFFSET, NULL);
if (height < NAME_HIGHLIGHT_THRESH) {
- gtk_canvas_item_set(name_text, "fill_color_rgba", fill_color, NULL) ;
+ gnome_canvas_item_set(name_text, "fill_color_rgba", fill_color, NULL) ;
}
else {
- gtk_canvas_item_set(name_text, "fill_color_rgba", label_color, NULL) ;
+ gnome_canvas_item_set(name_text, "fill_color_rgba", label_color, NULL) ;
}
}
if (frame) {
- gtk_canvas_item_set (frame, "y2", height+1, NULL) ;
+ gnome_canvas_item_set (frame, "y2", height+1, NULL) ;
}
- gtk_canvas_item_set (vestigial_frame, "y2", height+1, NULL) ;
+ gnome_canvas_item_set (vestigial_frame, "y2", height+1, NULL) ;
}
/**
/**
*
*/
-GtkCanvasItem*
+GnomeCanvasItem*
TimeAxisViewItem::get_canvas_frame()
{
return(frame) ;
/**
*
*/
-GtkCanvasItem*
+GnomeCanvasItem*
TimeAxisViewItem::get_canvas_group()
{
return(group) ;
/**
*
*/
-GtkCanvasItem*
+GnomeCanvasItem*
TimeAxisViewItem::get_name_highlight()
{
return(name_highlight) ;
/**
*
*/
-GtkCanvasItem*
+GnomeCanvasItem*
TimeAxisViewItem::get_name_text()
{
return(name_text) ;
}
if (height < NAME_HIGHLIGHT_THRESH) {
- gtk_canvas_item_set(name_text, "fill_color_rgba", fill_color, NULL) ;
+ gnome_canvas_item_set(name_text, "fill_color_rgba", fill_color, NULL) ;
}
else {
- gtk_canvas_item_set(name_text, "fill_color_rgba", label_color, NULL) ;
+ gnome_canvas_item_set(name_text, "fill_color_rgba", label_color, NULL) ;
}
}
if (name_highlight) {
- gtk_canvas_item_set(name_highlight, "fill_color_rgba", fill_color, NULL) ;
- gtk_canvas_item_set(name_highlight, "outline_color_rgba", fill_color, NULL) ;
+ gnome_canvas_item_set(name_highlight, "fill_color_rgba", fill_color, NULL) ;
+ gnome_canvas_item_set(name_highlight, "outline_color_rgba", fill_color, NULL) ;
}
set_trim_handle_colors() ;
}
if (_selected && should_show_selection) {
UINT_TO_RGBA(color_map[cSelectedFrameBase], &r, &g, &b, &a);
- gtk_canvas_item_set(frame, "fill_color_rgba", RGBA_TO_UINT(r, g, b, fill_opacity), NULL) ;
+ gnome_canvas_item_set(frame, "fill_color_rgba", RGBA_TO_UINT(r, g, b, fill_opacity), NULL) ;
} else {
UINT_TO_RGBA(color_map[cFrameBase], &r, &g, &b, &a);
- gtk_canvas_item_set(frame, "fill_color_rgba", RGBA_TO_UINT(r, g, b, fill_opacity), NULL) ;
+ gnome_canvas_item_set(frame, "fill_color_rgba", RGBA_TO_UINT(r, g, b, fill_opacity), NULL) ;
}
}
}
{
if (frame_handle_start) {
if (position_locked) {
- gtk_canvas_item_set(frame_handle_start, "fill_color_rgba", color_map[cTrimHandleLockedStart], NULL);
- gtk_canvas_item_set(frame_handle_end, "fill_color_rgba", color_map[cTrimHandleLockedEnd], NULL) ;
+ gnome_canvas_item_set(frame_handle_start, "fill_color_rgba", color_map[cTrimHandleLockedStart], NULL);
+ gnome_canvas_item_set(frame_handle_end, "fill_color_rgba", color_map[cTrimHandleLockedEnd], NULL) ;
} else {
- gtk_canvas_item_set(frame_handle_start, "fill_color_rgba", color_map[cTrimHandleStart], NULL) ;
- gtk_canvas_item_set(frame_handle_end, "fill_color_rgba", color_map[cTrimHandleEnd], NULL) ;
+ gnome_canvas_item_set(frame_handle_start, "fill_color_rgba", color_map[cTrimHandleStart], NULL) ;
+ gnome_canvas_item_set(frame_handle_end, "fill_color_rgba", color_map[cTrimHandleEnd], NULL) ;
}
}
}
if (pixel_width < GRAB_HANDLE_LENGTH * 2) {
if (frame_handle_start) {
- gtk_canvas_item_hide (frame_handle_start);
- gtk_canvas_item_hide (frame_handle_end);
+ gnome_canvas_item_hide (frame_handle_start);
+ gnome_canvas_item_hide (frame_handle_end);
}
} if (pixel_width < 2.0) {
if (show_vestigial) {
- gtk_canvas_item_show (vestigial_frame);
+ gnome_canvas_item_show (vestigial_frame);
}
if (name_highlight) {
- gtk_canvas_item_hide (name_highlight);
- gtk_canvas_item_hide (name_text);
+ gnome_canvas_item_hide (name_highlight);
+ gnome_canvas_item_hide (name_text);
}
if (frame) {
- gtk_canvas_item_hide (frame);
+ gnome_canvas_item_hide (frame);
}
if (frame_handle_start) {
- gtk_canvas_item_hide (frame_handle_start);
- gtk_canvas_item_hide (frame_handle_end);
+ gnome_canvas_item_hide (frame_handle_start);
+ gnome_canvas_item_hide (frame_handle_end);
}
} else {
- gtk_canvas_item_hide (vestigial_frame);
+ gnome_canvas_item_hide (vestigial_frame);
if (name_highlight) {
double height = GTK_VALUE_DOUBLE (args[0]);
if (height < NAME_HIGHLIGHT_THRESH) {
- gtk_canvas_item_hide (name_highlight);
- gtk_canvas_item_hide (name_text);
+ gnome_canvas_item_hide (name_highlight);
+ gnome_canvas_item_hide (name_text);
} else {
- gtk_canvas_item_show (name_highlight);
- gtk_canvas_item_show (name_text);
+ gnome_canvas_item_show (name_highlight);
+ gnome_canvas_item_show (name_text);
reset_name_width (pixel_width);
}
- gtk_canvas_item_set (name_highlight, "x2", pixel_width - 1.0, NULL);
+ gnome_canvas_item_set (name_highlight, "x2", pixel_width - 1.0, NULL);
}
if (frame) {
- gtk_canvas_item_show (frame);
- gtk_canvas_item_set (frame, "x2", pixel_width, NULL);
+ gnome_canvas_item_show (frame);
+ gnome_canvas_item_set (frame, "x2", pixel_width, NULL);
}
if (frame_handle_start) {
if (pixel_width < (2*TimeAxisViewItem::GRAB_HANDLE_LENGTH)) {
- gtk_canvas_item_hide (frame_handle_start);
- gtk_canvas_item_hide (frame_handle_end);
+ gnome_canvas_item_hide (frame_handle_start);
+ gnome_canvas_item_hide (frame_handle_end);
}
- gtk_canvas_item_show (frame_handle_start);
- gtk_canvas_item_set(GTK_CANVAS_ITEM(frame_handle_end), "x1", pixel_width - (TimeAxisViewItem::GRAB_HANDLE_LENGTH ), NULL) ;
- gtk_canvas_item_show (frame_handle_end);
- gtk_canvas_item_set(GTK_CANVAS_ITEM(frame_handle_end), "x2", pixel_width, NULL) ;
+ gnome_canvas_item_show (frame_handle_start);
+ gnome_canvas_item_set(GNOME_CANVAS_ITEM(frame_handle_end), "x1", pixel_width - (TimeAxisViewItem::GRAB_HANDLE_LENGTH ), NULL) ;
+ gnome_canvas_item_show (frame_handle_end);
+ gnome_canvas_item_set(GNOME_CANVAS_ITEM(frame_handle_end), "x2", pixel_width, NULL) ;
}
}
}
if (namelen == 0) {
- gtk_canvas_item_hide (name_text);
+ gnome_canvas_item_hide (name_text);
} else {
}
}
- gtk_canvas_item_set (name_text, "text", cstr, NULL);
- gtk_canvas_item_show (name_text);
+ gnome_canvas_item_set (name_text, "text", cstr, NULL);
+ gnome_canvas_item_show (name_text);
}
}
#define __gtk_ardour_time_axis_view_item_h__
#include <sigc++/signal.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <jack/jack.h>
#include <string>
/**
*
*/
- GtkCanvasItem* get_canvas_frame() ;
+ GnomeCanvasItem* get_canvas_frame() ;
/**
*
*/
- GtkCanvasItem* get_canvas_group();
+ GnomeCanvasItem* get_canvas_group();
/**
*
*/
- GtkCanvasItem* get_name_highlight();
+ GnomeCanvasItem* get_name_highlight();
/**
*
*/
- GtkCanvasItem* get_name_text();
+ GnomeCanvasItem* get_name_text();
/**
* Sets the samples per unit of this item.
* @param start the start point of this item
* @param duration the duration of this item
*/
- TimeAxisViewItem(std::string it_name, GtkCanvasGroup* parent, TimeAxisView& tv, double spu, GdkColor& base_color,
+ TimeAxisViewItem(std::string it_name, GnomeCanvasGroup* parent, TimeAxisView& tv, double spu, GdkColor& base_color,
jack_nframes_t start, jack_nframes_t duration, Visibility v = Visibility (0));
/**
uint32_t lock_handle_color_g ;
uint32_t lock_handle_color_b ;
- GtkCanvasItem* group ; /* the group */
- GtkCanvasItem* vestigial_frame ; /* simplerect */
- GtkCanvasItem* frame ; /* simplerect */
- GtkCanvasItem* name_text ; /* text */
- GtkCanvasItem* name_highlight ; /* simplerect */
- GtkCanvasItem* frame_handle_start ; /* simplerect */
- GtkCanvasItem* frame_handle_end ; /* simplerect */
+ GnomeCanvasItem* group ; /* the group */
+ GnomeCanvasItem* vestigial_frame ; /* simplerect */
+ GnomeCanvasItem* frame ; /* simplerect */
+ GnomeCanvasItem* name_text ; /* text */
+ GnomeCanvasItem* name_highlight ; /* simplerect */
+ GnomeCanvasItem* frame_handle_start ; /* simplerect */
+ GnomeCanvasItem* frame_handle_end ; /* simplerect */
}; /* class TimeAxisViewItem */
return (savergb);
}
-GtkCanvasPoints*
+GnomeCanvasPoints*
get_canvas_points (string who, uint32_t npoints)
{
// cerr << who << ": wants " << npoints << " canvas points" << endl;
abort ();
}
#endif
- return gtk_canvas_points_new (npoints);
+ return gnome_canvas_points_new (npoints);
}
int
#include <vector>
#include <cmath>
#include <ardour/types.h>
-#include <gtk-canvas.h>
-#include <gdk--/types.h>
+#include <libgnomecanvas/libgnomecanvas.h>
+#include <gdkmm/types.h>
namespace Gtk {
class Window;
unsigned char* xpm2rgb (const char** xpm, uint32_t& w, uint32_t& h);
unsigned char* xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h);
-GtkCanvasPoints* get_canvas_points (std::string who, uint32_t npoints);
+GnomeCanvasPoints* get_canvas_points (std::string who, uint32_t npoints);
int channel_combo_get_channel_count (Gtk::Combo& combo);
std::string get_font_for_style (std::string widgetname);
#define __ardour_visual_time_axis_h__
#include <gtkmm.h>
-#include <gtk-canvas.h>
+#include <libgnomecanvas/libgnomecanvas.h>
#include <gtkmm2ext/selector.h>
#include <gtkmm2ext/popup_selector.h>
projects / ardour.git / commitdiff