class lock
{
public:
- lock(mutex_null &x) { }
+ lock(mutex_null &/*x*/) { }
};
void lock_mutex(){}
return ret;
}
-Color BooleanCurve::get_color(Context context, const Point &pos)const
+Color BooleanCurve::get_color(Context /*context*/, const Point &/*pos*/)const
{
Color c(Color::alpha());
return c;
}
-bool BooleanCurve::accelerated_render(Context context,Surface *surface,int quality, const RendDesc &renddesc, ProgressCallback *cb)const
+bool BooleanCurve::accelerated_render(Context /*context*/,Surface */*surface*/,int /*quality*/, const RendDesc &/*renddesc*/, ProgressCallback */*cb*/)const
{
return false;
}
}
bool
-bmp_mptr::get_frame(synfig::Surface &surface,Time time, synfig::ProgressCallback *cb)
+bmp_mptr::get_frame(synfig::Surface &surface,Time /*time*/, synfig::ProgressCallback *cb)
{
FILE *file=fopen(filename.c_str(),"rb");
if(!file)
}
Color *
-bmp::start_scanline(int scanline)
+bmp::start_scanline(int /*scanline*/)
{
return color_buffer;
}
}
bool
-dv_trgt::start_frame(synfig::ProgressCallback *callback)
+dv_trgt::start_frame(synfig::ProgressCallback */*callback*/)
{
int w=desc.get_w(),h=desc.get_h();
}
Color *
-dv_trgt::start_scanline(int scanline)
+dv_trgt::start_scanline(int /*scanline*/)
{
return color_buffer;
}
}
bool
-ffmpeg_trgt::start_frame(synfig::ProgressCallback *callback)
+ffmpeg_trgt::start_frame(synfig::ProgressCallback */*callback*/)
{
int w=desc.get_w(),h=desc.get_h();
}
Color *
-ffmpeg_trgt::start_scanline(int scanline)
+ffmpeg_trgt::start_scanline(int /*scanline*/)
{
return color_buffer;
}
}
inline float
-Halftone2::calc_supersample(const synfig::Point &x, float pw,float ph)const
+Halftone2::calc_supersample(const synfig::Point &/*x*/, float pw,float /*ph*/)const
{
return abs(pw/(halftone.size).mag());
}
synfig::Layer::Handle
-Halftone2::hit_check(synfig::Context context, const synfig::Point &point)const
+Halftone2::hit_check(synfig::Context /*context*/, const synfig::Point &/*point*/)const
{
return const_cast<Halftone2*>(this);
}
}
inline float
-Halftone3::calc_supersample(const synfig::Point &x, float pw,float ph)const
+Halftone3::calc_supersample(const synfig::Point &/*x*/, float pw,float /*ph*/)const
{
return abs(pw/(tone[0].size).mag());
}
synfig::Layer::Handle
-Halftone3::hit_check(synfig::Context context, const synfig::Point &point)const
+Halftone3::hit_check(synfig::Context /*context*/, const synfig::Point &/*point*/)const
{
return const_cast<Halftone3*>(this);
}
}
float
-CurveGradient::calc_supersample(const synfig::Point &x, float pw,float ph)const
+CurveGradient::calc_supersample(const synfig::Point &/*x*/, float pw,float /*ph*/)const
{
return pw;
}
}
float
-LinearGradient::calc_supersample(const synfig::Point &x, float pw,float ph)const
+LinearGradient::calc_supersample(const synfig::Point &/*x*/, float pw,float /*ph*/)const
{
return pw/(p2-p1).mag();
}
float
-RadialGradient::calc_supersample(const synfig::Point &x, float pw,float ph)const
+RadialGradient::calc_supersample(const synfig::Point &/*x*/, float pw,float /*ph*/)const
{
// return sqrt(pw*pw+ph*ph)/radius;
return 1.2*pw/radius;
}
float
-SpiralGradient::calc_supersample(const synfig::Point &x, float pw,float ph)const
+SpiralGradient::calc_supersample(const synfig::Point &x, float pw,float /*ph*/)const
{
return (1.41421*pw/radius+(1.41421*pw/Point(x-center).mag())/(PI*2))*0.5;
}
}
bool
-imagemagick_mptr::get_frame(synfig::Surface &surface,Time time, synfig::ProgressCallback *cb)
+imagemagick_mptr::get_frame(synfig::Surface &surface,Time /*time*/, synfig::ProgressCallback *cb)
{
//#define HAS_LIBPNG 1
}
Color *
-imagemagick_trgt::start_scanline(int scanline)
+imagemagick_trgt::start_scanline(int /*scanline*/)
{
return color_buffer;
}
}
bool
-jpeg_mptr::get_frame(synfig::Surface &surface,Time, synfig::ProgressCallback *cb)
+jpeg_mptr::get_frame(synfig::Surface &surface,Time, synfig::ProgressCallback */*cb*/)
{
surface.mirror(surface_buffer);
return true;
}
Color *
-jpeg_trgt::start_scanline(int scanline)
+jpeg_trgt::start_scanline(int /*scanline*/)
{
return color_buffer;
}
}
bool
-Importer_LibAVCodec::get_frame(synfig::Surface &surface,Time, synfig::ProgressCallback *cb)
+Importer_LibAVCodec::get_frame(synfig::Surface &/*surface*/,Time, synfig::ProgressCallback */*cb*/)
{
return false;
}
return true;
}
- void close(AVFormatContext *formatc, AVStream *stream)
+ void close(AVFormatContext */*formatc*/, AVStream *stream)
{
if(stream)
avcodec_close(stream->codec);
}
// add an audio output stream
- AVStream *add_audio_stream(int codec_id,const AudioInfo &aInfo)
+ AVStream *add_audio_stream(int codec_id,const AudioInfo &/*aInfo*/)
{
AVCodecContext *context;
AVStream *stream;
}
bool
-Target_LibAVCodec::start_frame(synfig::ProgressCallback *callback)
+Target_LibAVCodec::start_frame(synfig::ProgressCallback */*callback*/)
{
//prepare all the color buffer stuff, etc.
}
inline Color
-NoiseDistort::color_func(const Point &point, float supersample,Context context)const
+NoiseDistort::color_func(const Point &point, float /*supersample*/,Context context)const
{
Color ret(0,0,0,0);
}
inline float
-NoiseDistort::calc_supersample(const synfig::Point &x, float pw,float ph)const
+NoiseDistort::calc_supersample(const synfig::Point &/*x*/, float /*pw*/,float /*ph*/)const
{
return 0.0f;
}
inline Color
-Noise::color_func(const Point &point, float pixel_size,Context context)const
+Noise::color_func(const Point &point, float pixel_size,Context /*context*/)const
{
Color ret(0,0,0,0);
}
inline float
-Noise::calc_supersample(const synfig::Point &x, float pw,float ph)const
+Noise::calc_supersample(const synfig::Point &/*x*/, float /*pw*/,float /*ph*/)const
{
return 0.0f;
}
/* === M E T H O D S ======================================================= */
void
-png_mptr::png_out_error(png_struct *png_data,const char *msg)
+png_mptr::png_out_error(png_struct */*png_data*/,const char *msg)
{
//png_mptr *me=(png_mptr*)png_data->error_ptr;
synfig::error(strprintf("png_mptr: error: %s",msg));
}
void
-png_mptr::png_out_warning(png_struct *png_data,const char *msg)
+png_mptr::png_out_warning(png_struct */*png_data*/,const char *msg)
{
//png_mptr *me=(png_mptr*)png_data->error_ptr;
synfig::warning(strprintf("png_mptr: warning: %s",msg));
}
int
-png_mptr::read_chunk_callback(png_struct *png_data, png_unknown_chunkp chunk)
+png_mptr::read_chunk_callback(png_struct */*png_data*/, png_unknown_chunkp /*chunk*/)
{
/* The unknown chunk structure contains your
chunk data: */
}
bool
-png_mptr::get_frame(synfig::Surface &surface,Time, synfig::ProgressCallback *cb)
+png_mptr::get_frame(synfig::Surface &surface,Time, synfig::ProgressCallback */*cb*/)
{
surface.mirror(surface_buffer);
// surface=surface_buffer;
}
Color *
-png_trgt::start_scanline(int scanline)
+png_trgt::start_scanline(int /*scanline*/)
{
return color_buffer;
}
}
Color *
-ppm::start_scanline(int scanline)
+ppm::start_scanline(int /*scanline*/)
{
return color_buffer;
}
}
bool
-yuv::start_frame(synfig::ProgressCallback *callback)
+yuv::start_frame(synfig::ProgressCallback */*callback*/)
{
return static_cast<bool>(file);
}
}
void
-Context::set_time(Time time,const Vector &pos)const
+Context::set_time(Time time,const Vector &/*pos*/)const
{
set_time(time);
/*
}
}
- bool ConstructSet(CurveSet &c, const CurveSet &lhs, const CurveSet &rhs, int type)
+ bool ConstructSet(CurveSet &/*c*/, const CurveSet &lhs, const CurveSet &rhs, int type)
{
bool in1,in2;
}
}
-void CurveSet::CleanUp(int curve)
+void CurveSet::CleanUp(int /*curve*/)
{
}
- only works with odd-even rule
*/
-CurveSet CurveSet::operator &(const CurveSet &rhs) const
+CurveSet CurveSet::operator &(const CurveSet &/*rhs*/) const
{
return *this;
}
-CurveSet CurveSet::operator |(const CurveSet &rhs) const
+CurveSet CurveSet::operator |(const CurveSet &/*rhs*/) const
{
return *this;
}
-CurveSet CurveSet::operator -(const CurveSet &rhs) const
+CurveSet CurveSet::operator -(const CurveSet &/*rhs*/) const
{
return *this;
}
public:
virtual ~ProgressCallback() { }
- virtual bool task(const String &task) { return true; }
- virtual bool error(const String &task) { return true; }
- virtual bool warning(const String &task) { return true; }
- virtual bool amount_complete(int current, int total) { return true; }
+ virtual bool task(const String &/*task*/) { return true; }
+ virtual bool error(const String &/*task*/) { return true; }
+ virtual bool warning(const String &/*task*/) { return true; }
+ virtual bool amount_complete(int /*current*/, int /*total*/) { return true; }
virtual bool valid() const { return true; }
};
}
bool
-Layer::set_version(const String &ver)
+Layer::set_version(const String &/*ver*/)
{
return false;
}
** is anything but accelerated...
*/
bool
-Layer::accelerated_render(Context context,Surface *surface,int quality, const RendDesc &renddesc, ProgressCallback *cb) const
+Layer::accelerated_render(Context context,Surface *surface,int /*quality*/, const RendDesc &renddesc, ProgressCallback *cb) const
{
handle<Target> target=surface_target(surface);
if(!target)
degrees.push_back(2);
}
- static int intersect_conic(Real x, Real y, Point *p, int level = 0)
+ static int intersect_conic(Real x, Real y, Point *p, int /*level*/ = 0)
{
Real ymin,ymax,xmin,xmax;
int intersects = 0;
}
}
- static int intersect_cubic(Real x, Real y, Point *p, int level = 0)
+ static int intersect_cubic(Real x, Real y, Point *p, int /*level*/ = 0)
{
const Real INVALIDROOT = -FLT_MAX;
Real ymin,ymax,xmin,xmax;
}
bool
-Layer_Shape::render_shape(Surface *surface,bool useblend,int quality,
+Layer_Shape::render_shape(Surface *surface,bool useblend,int /*quality*/,
const RendDesc &renddesc, ProgressCallback *cb)const
{
int tmp(0);
}
bool
-Layer_Shape::render_shape(surface<float> *surface,int quality,
- const RendDesc &renddesc, ProgressCallback *cb)const
+Layer_Shape::render_shape(surface<float> *surface,int /*quality*/,
+ const RendDesc &renddesc, ProgressCallback */*cb*/)const
{
// If our amount is set to zero, no need to render anything
if(!get_amount())
return ret;
}
-static void broken_pipe_signal (int sig) {
+static void broken_pipe_signal (int /*sig*/) {
synfig::warning("Broken Pipe...");
}
synfig::Module* _##x##_LTX_new_instance(synfig::ProgressCallback *cb) \
{ if(SYNFIG_CHECK_VERSION()){x##_modclass *mod=new x##_modclass(cb); mod->constructor_(cb); return mod; }\
if(cb)cb->error(#x": Unable to load module due to version mismatch."); return NULL; } \
- }; x##_modclass::x##_modclass(synfig::ProgressCallback *cb) {
+ }; x##_modclass::x##_modclass(synfig::ProgressCallback */*cb*/) {
#else
//! Marks the start of a module's inventory
#define MODULE_INVENTORY_BEGIN(x) extern "C" { \
synfig::Module* x##_LTX_new_instance(synfig::ProgressCallback *cb) \
{ if(SYNFIG_CHECK_VERSION()){x##_modclass *mod=new x##_modclass(cb); mod->constructor_(cb); return mod; }\
if(cb)cb->error(#x": Unable to load module due to version mismatch."); return NULL; } \
- }; x##_modclass::x##_modclass(synfig::ProgressCallback *cb) {
+ }; x##_modclass::x##_modclass(synfig::ProgressCallback */*cb*/) {
#endif
//! Marks the start of the layers in the module's inventory
class Module : public etl::shared_object
{
public:
- bool constructor_(synfig::ProgressCallback *cb) { return true; }
+ bool constructor_(synfig::ProgressCallback */*cb*/) { return true; }
virtual void destructor_() { }
typedef etl::handle<Module> Handle;
return root;
}
-xmlpp::Element* encode_time(xmlpp::Element* root,Time t, float fps=0)
+xmlpp::Element* encode_time(xmlpp::Element* root,Time t, float /*fps*/=0)
{
root->set_name("time");
//root->set_attribute("value",t.get_string(fps));
}
bool
-target2surface::start_frame(synfig::ProgressCallback *cb)
+target2surface::start_frame(synfig::ProgressCallback */*cb*/)
{
if(surface->get_w() != desc.get_w() || surface->get_h() != desc.get_h())
{
~Target_Null() { delete buffer; }
- virtual bool start_frame(ProgressCallback *cb=NULL)
+ virtual bool start_frame(ProgressCallback */*cb*/=NULL)
{ delete buffer; buffer=new Color[desc.get_w()*sizeof(Color)]; return true; }
virtual void end_frame() { delete buffer; buffer=0; return; }
- virtual Color * start_scanline(int scanline) { return buffer; }
+ virtual Color * start_scanline(int /*scanline*/) { return buffer; }
virtual bool end_scanline() { return true; }
- static Target* create(const char *filename=0) { return new Target_Null(); }
+ static Target* create(const char */*filename*/=0) { return new Target_Null(); }
}; // END of class Target_Null
}; // END of namespace synfig
public:
~Target_Null_Tile() { }
- virtual bool add_tile(const synfig::Surface &surface, int x, int y) { return true; }
+ virtual bool add_tile(const synfig::Surface &/*surface*/, int /*x*/, int /*y*/) { return true; }
- virtual bool start_frame(ProgressCallback *cb=NULL)
+ virtual bool start_frame(ProgressCallback */*cb*/=NULL)
{ return true; }
virtual void end_frame() { return; }
- static Target* create(const char *filename=0) { return new Target_Null_Tile(); }
+ static Target* create(const char */*filename*/=0) { return new Target_Null_Tile(); }
}; // END of class Target_Null_Tile
}; // END of namespace synfig
//! \writeme
int
-synfig::activepoint_collect(set<Activepoint, std::less<UniqueID> >& activepoint_set,const Time& time, const etl::handle<Node>& node)
+synfig::activepoint_collect(set<Activepoint, std::less<UniqueID> >& /*activepoint_set*/,const Time& time, const etl::handle<Node>& node)
{
const TimePointSet& timepoint_set(node->get_times());
static const Type get_type(const etl::loose_handle<Canvas>&)
{ return TYPE_CANVAS; }
static const Type get_type(const list_type&) { return TYPE_LIST; }
- template <class T> static const Type get_type(const std::vector<T> &x)
+ template <class T> static const Type get_type(const std::vector<T> &/*x*/)
{ return TYPE_LIST; }
- template <class T> static const Type get_type(const std::list<T> &x)
+ template <class T> static const Type get_type(const std::list<T> &/*x*/)
{ return TYPE_LIST; }
// ========================================================================
}
ValueBase
-PlaceholderValueNode::operator()(Time t)const
+PlaceholderValueNode::operator()(Time /*t*/)const
{
assert(0);
return ValueBase();
public:
//! Returns the value of the ValueNode at time \a t
- virtual ValueBase operator()(Time t)const
+ virtual ValueBase operator()(Time /*t*/)const
{ return ValueBase(); }
//! \internal Sets the id of the ValueNode
static Handle create(ValueBase::Type type=ValueBase::TYPE_NIL);
protected:
- virtual void get_times_vfunc(Node::time_set &set) const {}
+ virtual void get_times_vfunc(Node::time_set &/*set*/) const {}
}; // END of class PlaceholderValueNode
ValueBase
-ValueNode_Const::operator()(Time t)const
+ValueNode_Const::operator()(Time /*t*/)const
{
return value;
}
return _("Constant");
}
-void ValueNode_Const::get_times_vfunc(Node::time_set &set) const
+void ValueNode_Const::get_times_vfunc(Node::time_set &/*set*/) const
{
}
}
String
-ValueNode_Reference::link_name(int i)const
+ValueNode_Reference::link_name(int /*i*/)const
{
return "link";
}
{ return (&a)[i]; }
//! Bezier curve intersection function
- time_type intersect(const bezier_base<value_type,time_type> &x, time_type near=0.0)const
+ time_type intersect(const bezier_base<value_type,time_type> &/*x*/, time_type /*near*/=0.0)const
{
return 0;
}
}
virtual bool
- amount_complete(int current, int total)
+ amount_complete(int /*current*/, int /*total*/)
{
return true;
}
}
virtual bool
- amount_complete(int current, int total)
+ amount_complete(int /*current*/, int /*total*/)
{
while(studio::App::events_pending())studio::App::iteration(false);
return true;
}
+#ifdef _WIN32
+# ifdef LICENSE_KEY_REQUIRED
int check_license(String basedir)
+# else
+int check_license(String /*basedir*/)
+# endif
+#else
+int check_license(String /*basedir*/)
+#endif
{
#ifdef LICENSE_KEY_REQUIRED
String key;
dialog_setup->show();
}
-gint Signal_Open_Ok(GtkWidget *widget, int *val){*val=1;return 0;}
-gint Signal_Open_Cancel(GtkWidget *widget, int *val){*val=2;return 0;}
+gint Signal_Open_Ok(GtkWidget */*widget*/, int *val){*val=1;return 0;}
+gint Signal_Open_Cancel(GtkWidget */*widget*/, int *val){*val=2;return 0;}
//#ifdef WIN32
//#define USE_WIN32_FILE_DIALOGS 1
alive_flag=false;
}
- virtual bool start_frame(synfig::ProgressCallback *cb=0)
+ virtual bool start_frame(synfig::ProgressCallback */*cb*/=0)
{
return alive_flag;
}
struct FSOUND_SAMPLE;
using studio::AudioContainer;
+#ifdef WITH_FMOD
bool build_profile(FSOUND_SAMPLE *sample, double &samplerate, std::vector<char> &samples)
+#else
+bool build_profile(FSOUND_SAMPLE */*sample*/, double &/*samplerate*/, std::vector<char> &/*samples*/)
+#endif
{
#ifdef WITH_FMOD
scrubinfo *scrptr;
bool is_scrubbing() const {return scrptr != 0;}
+#ifdef WITH_FMOD
void set_scrubbing(bool s)
+#else
+ void set_scrubbing(bool /*s*/)
+#endif
{
#ifdef WITH_FMOD
if(s)
}
//Will override the parameter timevalue if the sound is running, and not if it's not...
+#ifdef WITH_FMOD
bool get_current_time(double &out)
+#else
+ bool get_current_time(double &/*out*/)
+#endif
{
if(isRunning())
{
return imp->load(filename,filedirectory);
}
+#ifdef WITH_FMOD
handle<studio::AudioProfile> studio::AudioContainer::get_profile(float samplerate)
+#else
+handle<studio::AudioProfile> studio::AudioContainer::get_profile(float /*samplerate*/)
+#endif
{
#ifdef WITH_FMOD
//----------- Audio imp information -------------------
+#ifdef WITH_FMOD
bool studio::AudioContainer::AudioImp::load(const std::string &filename,
const std::string &filedirectory)
+#else
+bool studio::AudioContainer::AudioImp::load(const std::string &/*filename*/,
+ const std::string &/*filedirectory*/)
+#endif
{
clear();
#endif
}
+#ifdef WITH_FMOD
void studio::AudioContainer::AudioImp::play(double t)
+#else
+void studio::AudioContainer::AudioImp::play(double /*t*/)
+#endif
{
#ifdef WITH_FMOD
if(!sample) return;
playing = false;
}
+#ifdef WITH_FMOD
void AudioContainer::AudioImp::start_scrubbing(double t)
+#else
+void AudioContainer::AudioImp::start_scrubbing(double /*t*/)
+#endif
{
//synfig::info("Start scrubbing: %lf", t);
if(playing) stop();
curscrubpos = 0;
}
+#ifdef WITH_FMOD
void AudioContainer::AudioImp::scrub(double t)
+#else
+void AudioContainer::AudioImp::scrub(double /*t*/)
+#endif
{
#ifdef WITH_FMOD
//synfig::info("Scrub to %lf",t);
}
//! Sets which value_nodes should be selected
- virtual void set_selected_children(const ChildrenList &children_list)
+ virtual void set_selected_children(const ChildrenList &/*children_list*/)
{
return;
}
//! Sets which value_node should be selected. Empty handle if none.
- virtual void set_selected_child(const ChildrenList::value_type &child)
+ virtual void set_selected_child(const ChildrenList::value_type &/*child*/)
{
return;
}
return get_selected_layer_parameters().front();
}
- void set_selected_layer_parameters(const LayerParamList &layer_param_list)
+ void set_selected_layer_parameters(const LayerParamList &/*layer_param_list*/)
{
return;
}
- void set_selected_layer_param(const LayerParam &layer_param)
+ void set_selected_layer_param(const LayerParam &/*layer_param*/)
{
return;
}
}
void
-CanvasView::register_layer_type(synfig::Layer::Book::value_type &lyr,std::map<synfig::String,Gtk::Menu*>* category_map)
+CanvasView::register_layer_type(synfig::Layer::Book::value_type &/*lyr*/,std::map<synfig::String,Gtk::Menu*>* /*category_map*/)
{
/* if(lyr.second.category==_("Do Not Use"))
return;
}
void
-CanvasView::build_new_layer_menu(Gtk::Menu &menu)
+CanvasView::build_new_layer_menu(Gtk::Menu &/*menu*/)
{
/*
std::map<synfig::String,Gtk::Menu*> category_map;
}
bool
-CanvasView::on_layer_user_click(int button, Gtk::TreeRow row, LayerTree::ColumnID column_id)
+CanvasView::on_layer_user_click(int button, Gtk::TreeRow /*row*/, LayerTree::ColumnID /*column_id*/)
{
switch(button)
{
}
void
-CanvasView::on_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& selection_data_, guint info, guint time)
+CanvasView::on_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int /*x*/, int /*y*/, const Gtk::SelectionData& selection_data_, guint /*info*/, guint time)
{
// We will make this true once we have a solid drop
bool success(false);
void
CellRenderer_Gradient::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& window,
- Gtk::Widget& widget,
- const Gdk::Rectangle& background_area,
+ Gtk::Widget& /*widget*/,
+ const Gdk::Rectangle& /*background_area*/,
const Gdk::Rectangle& ca,
- const Gdk::Rectangle& expose_area,
- Gtk::CellRendererState flags)
+ const Gdk::Rectangle& /*expose_area*/,
+ Gtk::CellRendererState /*flags*/)
{
if(!window)
return;
Gtk::CellEditable*
CellRenderer_Gradient::start_editing_vfunc(
- GdkEvent* event,
- Gtk::Widget& widget,
- const Glib::ustring& path,
- const Gdk::Rectangle& background_area,
- const Gdk::Rectangle& cell_area,
- Gtk::CellRendererState flags)
+ GdkEvent* /*event*/,
+ Gtk::Widget& /*widget*/,
+ const Glib::ustring& /*path*/,
+ const Gdk::Rectangle& /*background_area*/,
+ const Gdk::Rectangle& /*cell_area*/,
+ Gtk::CellRendererState /*flags*/)
{
return 0;
}
CellRenderer_TimeTrack::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& window,
Gtk::Widget& widget,
- const Gdk::Rectangle& background_area,
+ const Gdk::Rectangle& /*background_area*/,
const Gdk::Rectangle& area_,
- const Gdk::Rectangle& expose_area,
- Gtk::CellRendererState flags)
+ const Gdk::Rectangle& /*expose_area*/,
+ Gtk::CellRendererState /*flags*/)
{
if(!window)
return;
}
synfig::ValueNode_Animated::WaypointList::iterator
-CellRenderer_TimeTrack::find_waypoint(const synfig::Time& t,const synfig::Time& scope)
+CellRenderer_TimeTrack::find_waypoint(const synfig::Time& /*t*/,const synfig::Time& scope)
{
synfig::ValueNode_Animated *value_node=dynamic_cast<synfig::ValueNode_Animated*>(property_value_desc().get_value().get_value_node().get());
bool
CellRenderer_TimeTrack::activate_vfunc(
GdkEvent* event,
- Gtk::Widget& widget,
+ Gtk::Widget& /*widget*/,
const Glib::ustring& treepath,
- const Gdk::Rectangle& background_area,
+ const Gdk::Rectangle& /*background_area*/,
const Gdk::Rectangle& cell_area,
- Gtk::CellRendererState flags)
+ Gtk::CellRendererState /*flags*/)
{
path=treepath;
synfig::ValueNode_Animated::WaypointList::iterator iter;
if(parent)parent->grab_focus();
Gtk::CellEditable::on_remove_widget();
}
- void start_editing_vfunc(GdkEvent *event)
+ void start_editing_vfunc(GdkEvent */*event*/)
{
valuewidget->signal_activate().connect(sigc::mem_fun(*this, &studio::ValueBase_Entry::editing_done));
show();
}
void
-ChildrenTreeStore::refresh_row(Gtk::TreeModel::Row &row, bool do_children)
+ChildrenTreeStore::refresh_row(Gtk::TreeModel::Row &row, bool /*do_children*/)
{
CanvasTreeStore::refresh_row(row,false);
}
void
-ChildrenTreeStore::on_canvas_removed(Canvas::Handle canvas)
+ChildrenTreeStore::on_canvas_removed(Canvas::Handle /*canvas*/)
{
rebuild_canvases();
}
}
void
-ChildrenTreeStore::on_value_node_replaced(synfig::ValueNode::Handle replaced_value_node,synfig::ValueNode::Handle new_value_node)
+ChildrenTreeStore::on_value_node_replaced(synfig::ValueNode::Handle replaced_value_node,synfig::ValueNode::Handle /*new_value_node*/)
{
changed_connection.disconnect();
//if(!execute_changed_queued())
}
static void
-dialog_gradient_value_desc_edit(synfig::Gradient g,synfigapp::ValueDesc x,handle<synfigapp::CanvasInterface> canvas_interface)
+dialog_gradient_value_desc_edit(synfig::Gradient /*g*/,synfigapp::ValueDesc /*x*/,handle<synfigapp::CanvasInterface> /*canvas_interface*/)
{
// canvas_interface->connect_value(x,ValueBase(g));
}
}
bool
-GammaPattern::redraw(GdkEventExpose*bleh)
+GammaPattern::redraw(GdkEventExpose */*bleh*/)
{
static const char hlines[] = { 3, 0 };
}
bool
-BlackLevelSelector::redraw(GdkEventExpose*bleh)
+BlackLevelSelector::redraw(GdkEventExpose */*bleh*/)
{
const int w(get_width()),h(get_height());
}
bool
-RedBlueLevelSelector::redraw(GdkEventExpose*bleh)
+RedBlueLevelSelector::redraw(GdkEventExpose */*bleh*/)
{
const int w(get_width()),h(get_height());
/* === E N T R Y P O I N T ================================================= */
-studio::Dialog_SoundSelect::Dialog_SoundSelect(Gtk::Window &parent, etl::handle<synfigapp::CanvasInterface> ci)
+studio::Dialog_SoundSelect::Dialog_SoundSelect(Gtk::Window &/*parent*/, etl::handle<synfigapp::CanvasInterface> ci)
:Dialog(_("Sound Select")),
okbutton(_("Ok")),
canvas_interface(ci)
}
void
-Dock_CanvasSpecific::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
+Dock_CanvasSpecific::init_canvas_view_vfunc(etl::loose_handle<CanvasView> /*canvas_view*/)
{
}
void
-Dock_CanvasSpecific::init_instance_vfunc(etl::loose_handle<Instance> instance)
+Dock_CanvasSpecific::init_instance_vfunc(etl::loose_handle<Instance> /*instance*/)
{
}
void
-Dock_CanvasSpecific::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
+Dock_CanvasSpecific::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> /*canvas_view*/)
{
}
}
void
-Dock_CanvasSpecific::delete_instance(etl::handle<Instance> instance)
+Dock_CanvasSpecific::delete_instance(etl::handle<Instance> /*instance*/)
{
changed_canvas_view_vfunc(0);
}
}else return -999999.0;
}
-bool studio::Widget_NavView::on_expose_draw(GdkEventExpose *exp)
+bool studio::Widget_NavView::on_expose_draw(GdkEventExpose */*exp*/)
{
//print out the zoom
//HACK kind of...
}
void
- on_waypoint_clicked(const Glib::ustring &path_string, synfig::Waypoint waypoint,int button)
+ on_waypoint_clicked(const Glib::ustring &/*path_string*/, synfig::Waypoint waypoint,int button)
{
/*
Gtk::TreePath path(path_string);
}
void
-Dockable::on_drag_end(const Glib::RefPtr<Gdk::DragContext>&context)
+Dockable::on_drag_end(const Glib::RefPtr<Gdk::DragContext>&/*context*/)
{
if(!dnd_success_)
{
}
void
-Dockable::on_drag_begin(const Glib::RefPtr<Gdk::DragContext>&context)
+Dockable::on_drag_begin(const Glib::RefPtr<Gdk::DragContext>&/*context*/)
{
dnd_success_=false;
}
void
-Dockable::on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&, Gtk::SelectionData& selection_data, guint info, guint time)
+Dockable::on_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&, Gtk::SelectionData& selection_data, guint /*info*/, guint /*time*/)
{
Dockable* tmp(this);
dnd_success_=true;
}
void
-HistoryTreeStore::insert_action(Gtk::TreeRow row,etl::handle<synfigapp::Action::Undoable> action, bool is_active, bool is_undo, bool is_redo)
+HistoryTreeStore::insert_action(Gtk::TreeRow row,etl::handle<synfigapp::Action::Undoable> action, bool /*is_active*/, bool is_undo, bool is_redo)
{
assert(action);
static Glib::RefPtr<Gdk::Pixbuf> _tree_pixbuf_table_value_type[(int)synfig::ValueBase::TYPE_END];
+#ifdef WIN32
IconControler::IconControler(const synfig::String& basepath)
+#else
+IconControler::IconControler(const synfig::String& /*basepath*/)
+#endif
{
Gtk::IconSource icon_source;
icon_source.set_direction_wildcarded();
}
void
-KeyframeTreeStore_Class::class_init_function(gpointer g_class, gpointer class_data)
+KeyframeTreeStore_Class::class_init_function(gpointer /*g_class*/, gpointer /*class_data*/)
{
// ???
}
}
inline void
-KeyframeTreeStore::dump_iterator(const GtkTreeIter* gtk_iter, const Glib::ustring &name)const
+KeyframeTreeStore::dump_iterator(const GtkTreeIter* /*gtk_iter*/, const Glib::ustring &/*name*/)const
{
#if 0
if(!gtk_iter)
bool
-LayerGroupTreeStore::row_draggable_vfunc (const TreeModel::Path& path)const
+LayerGroupTreeStore::row_draggable_vfunc (const TreeModel::Path& /*path*/)const
{
//if(!get_iter(path)) return false;
// Gtk::TreeModel::Row row(*get_iter(path));
}
bool
-LayerGroupTreeStore::drag_data_delete_vfunc (const TreeModel::Path& path)
+LayerGroupTreeStore::drag_data_delete_vfunc (const TreeModel::Path& /*path*/)
{
return true;
}
}
bool
-LayerGroupTreeStore::on_group_changed(synfig::String group)
+LayerGroupTreeStore::on_group_changed(synfig::String /*group*/)
{
//DEBUGPOINT();
return true;
}
void
-LayerGroupTreeStore::on_layer_status_changed(synfig::Layer::Handle handle,bool x)
+LayerGroupTreeStore::on_layer_status_changed(synfig::Layer::Handle handle,bool /*x*/)
{
Gtk::TreeModel::Children::iterator iter;
if(find_layer_row(handle,iter))
}
void
-LayerParamTreeStore::on_value_node_added(ValueNode::Handle value_node)
+LayerParamTreeStore::on_value_node_added(ValueNode::Handle /*value_node*/)
{
// queue_refresh();
}
void
-LayerParamTreeStore::on_value_node_deleted(etl::handle<ValueNode> value_node)
+LayerParamTreeStore::on_value_node_deleted(etl::handle<ValueNode> /*value_node*/)
{
// queue_refresh();
}
void
-LayerParamTreeStore::on_value_node_child_added(synfig::ValueNode::Handle value_node,synfig::ValueNode::Handle child)
+LayerParamTreeStore::on_value_node_child_added(synfig::ValueNode::Handle /*value_node*/,synfig::ValueNode::Handle /*child*/)
{
queue_rebuild();
}
void
-LayerParamTreeStore::on_value_node_child_removed(synfig::ValueNode::Handle value_node,synfig::ValueNode::Handle child)
+LayerParamTreeStore::on_value_node_child_removed(synfig::ValueNode::Handle /*value_node*/,synfig::ValueNode::Handle /*child*/)
{
rebuild();
}
void
-LayerParamTreeStore::on_value_node_changed(etl::handle<ValueNode> value_node)
+LayerParamTreeStore::on_value_node_changed(etl::handle<ValueNode> /*value_node*/)
{
queue_refresh();
}
void
-LayerParamTreeStore::on_value_node_replaced(synfig::ValueNode::Handle replaced_value_node,synfig::ValueNode::Handle new_value_node)
+LayerParamTreeStore::on_value_node_replaced(synfig::ValueNode::Handle /*replaced_value_node*/,synfig::ValueNode::Handle /*new_value_node*/)
{
queue_rebuild();
}
void
-LayerParamTreeStore::on_layer_param_changed(synfig::Layer::Handle handle,synfig::String param_name)
+LayerParamTreeStore::on_layer_param_changed(synfig::Layer::Handle /*handle*/,synfig::String /*param_name*/)
{
queue_refresh();
}
bool
-LayerTreeStore::row_draggable_vfunc (const TreeModel::Path& path)const
+LayerTreeStore::row_draggable_vfunc (const TreeModel::Path& /*path*/)const
{
//if(!get_iter(path)) return false;
// Gtk::TreeModel::Row row(*get_iter(path));
}
bool
-LayerTreeStore::drag_data_delete_vfunc (const TreeModel::Path& path)
+LayerTreeStore::drag_data_delete_vfunc (const TreeModel::Path& /*path*/)
{
return true;
}
}
void
-LayerTreeStore::on_layer_status_changed(synfig::Layer::Handle handle,bool x)
+LayerTreeStore::on_layer_status_changed(synfig::Layer::Handle handle,bool /*x*/)
{
Gtk::TreeModel::Children::iterator iter;
if(find_layer_row(handle,iter))
}
void
-LayerTreeStore::on_layer_moved(synfig::Layer::Handle layer,int depth, synfig::Canvas::Handle canvas)
+LayerTreeStore::on_layer_moved(synfig::Layer::Handle layer,int depth, synfig::Canvas::Handle /*canvas*/)
{
on_layer_removed(layer);
on_layer_inserted(layer,depth);
bool
-LayerTreeStore::find_layer_row_(const synfig::Layer::Handle &layer, synfig::Canvas::Handle canvas, Gtk::TreeModel::Children layers, Gtk::TreeModel::Children::iterator &iter, Gtk::TreeModel::Children::iterator &prev)
+LayerTreeStore::find_layer_row_(const synfig::Layer::Handle &layer, synfig::Canvas::Handle /*canvas*/, Gtk::TreeModel::Children layers, Gtk::TreeModel::Children::iterator &iter, Gtk::TreeModel::Children::iterator &prev)
{
assert(layer);
}
void
-MetaDataTreeStore::meta_data_changed(synfig::String key)
+MetaDataTreeStore::meta_data_changed(synfig::String /*key*/)
{
rebuild();
}
}
Smach::event_result
-StateMirror_Context::event_refresh_tool_options(const Smach::event& x)
+StateMirror_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
#endif
void
-DuckDrag_Mirror::begin_duck_drag(Duckmatic* duckmatic, const synfig::Vector& offset)
+DuckDrag_Mirror::begin_duck_drag(Duckmatic* duckmatic, const synfig::Vector& /*offset*/)
{
return false;
}
- virtual bool start_frame(ProgressCallback *cb=NULL)
+ virtual bool start_frame(ProgressCallback */*cb*/=NULL)
{
return true;
}
draw_area.queue_draw();//on_expose_event();
}
-bool studio::Widget_Preview::redraw(GdkEventExpose *heh)
+bool studio::Widget_Preview::redraw(GdkEventExpose */*heh*/)
{
//And render the drawing area
Glib::RefPtr<Gdk::Pixbuf> pxnew, px = currentbuf;
void
Renderer_BBox::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& drawable,
- const Gdk::Rectangle& expose_area
+ const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
void
Renderer_Canvas::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& drawable,
- const Gdk::Rectangle& expose_area
+ const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
void
Renderer_Dragbox::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& drawable,
- const Gdk::Rectangle& expose_area
+ const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
void
Renderer_Ducks::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& drawable,
- const Gdk::Rectangle& expose_area
+ const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
void
Renderer_Grid::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& drawable,
- const Gdk::Rectangle& expose_area
+ const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
void
Renderer_Guides::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& drawable,
- const Gdk::Rectangle& expose_area
+ const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
void
Renderer_Timecode::render_vfunc(
const Glib::RefPtr<Gdk::Drawable>& drawable,
- const Gdk::Rectangle& expose_area
+ const Gdk::Rectangle& /*expose_area*/
)
{
assert(get_work_area());
Smach::event_result event_mouse_motion_handler(const Smach::event& x);
Smach::event_result event_refresh_tool_options(const Smach::event& x);
- Smach::event_result event_hijack(const Smach::event& x) { return Smach::RESULT_ACCEPT; }
+ Smach::event_result event_hijack(const Smach::event& /*x*/) { return Smach::RESULT_ACCEPT; }
void refresh_tool_options();
bool run();
bool no_egress_on_selection_change;
- Smach::event_result event_layer_selection_changed_handler(const Smach::event& x)
+ Smach::event_result event_layer_selection_changed_handler(const Smach::event& /*x*/)
{
if(!no_egress_on_selection_change)
throw Smach::egress_exception();
}
Smach::event_result
-StateBLine_Context::event_refresh_tool_options(const Smach::event& x)
+StateBLine_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateBLine_Context::event_stop_handler(const Smach::event& x)
+StateBLine_Context::event_stop_handler(const Smach::event& /*x*/)
{
synfig::info("STATE RotoBLine: Received Stop Event");
// run();
}
Smach::event_result
-StateBLine_Context::event_refresh_handler(const Smach::event& x)
+StateBLine_Context::event_refresh_handler(const Smach::event& /*x*/)
{
synfig::info("STATE RotoBLine: Received Refresh Event");
refresh_ducks();
}
Smach::event_result
-StateBLine_Context::event_mouse_release_handler(const Smach::event& x)
+StateBLine_Context::event_mouse_release_handler(const Smach::event& /*x*/)
{
if(curr_duck)
{
void reset();
void increment_id();
bool no_egress_on_selection_change;
- Smach::event_result event_layer_selection_changed_handler(const Smach::event& x)
+ Smach::event_result event_layer_selection_changed_handler(const Smach::event& /*x*/)
{
if(!no_egress_on_selection_change)
throw Smach::egress_exception();
}
Smach::event_result
-StateCircle_Context::event_refresh_tool_options(const Smach::event& x)
+StateCircle_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateCircle_Context::event_stop_handler(const Smach::event& x)
+StateCircle_Context::event_stop_handler(const Smach::event& /*x*/)
{
throw Smach::egress_exception();
}
Smach::event_result
-StateCircle_Context::event_refresh_handler(const Smach::event& x)
+StateCircle_Context::event_refresh_handler(const Smach::event& /*x*/)
{
refresh_ducks();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateDraw_Context::event_refresh_tool_options(const Smach::event& x)
+StateDraw_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateDraw_Context::event_stop_handler(const Smach::event& x)
+StateDraw_Context::event_stop_handler(const Smach::event& /*x*/)
{
throw Smach::egress_exception();
}
Smach::event_result
-StateDraw_Context::event_refresh_handler(const Smach::event& x)
+StateDraw_Context::event_refresh_handler(const Smach::event& /*x*/)
{
refresh_ducks();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateEyedrop_Context::event_stop_handler(const Smach::event& x)
+StateEyedrop_Context::event_stop_handler(const Smach::event& /*x*/)
{
synfig::info("STATE EYEDROP: Received Stop Event");
throw Smach::egress_exception();
}
Smach::event_result
-StateEyedrop_Context::event_refresh_handler(const Smach::event& x)
+StateEyedrop_Context::event_refresh_handler(const Smach::event& /*x*/)
{
synfig::info("STATE EYEDROP: Received Refresh Event");
canvas_view->work_area->queue_render_preview();
}
Smach::event_result
-StateFill_Context::event_stop_handler(const Smach::event& x)
+StateFill_Context::event_stop_handler(const Smach::event& /*x*/)
{
synfig::info("STATE FILL: Received Stop Event");
throw Smach::egress_exception();
}
Smach::event_result
-StateFill_Context::event_refresh_handler(const Smach::event& x)
+StateFill_Context::event_refresh_handler(const Smach::event& /*x*/)
{
synfig::info("STATE FILL: Received Refresh Event");
canvas_view->work_area->queue_render_preview();
void make_gradient(const Point& p1, const Point& p2);
bool no_egress_on_selection_change;
- Smach::event_result event_layer_selection_changed_handler(const Smach::event& x)
+ Smach::event_result event_layer_selection_changed_handler(const Smach::event& /*x*/)
{
if(!no_egress_on_selection_change)
throw Smach::egress_exception();
}
Smach::event_result
-StateGradient_Context::event_refresh_tool_options(const Smach::event& x)
+StateGradient_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateGradient_Context::event_stop_handler(const Smach::event& x)
+StateGradient_Context::event_stop_handler(const Smach::event& /*x*/)
{
throw Smach::egress_exception();
}
Smach::event_result
-StateGradient_Context::event_refresh_handler(const Smach::event& x)
+StateGradient_Context::event_refresh_handler(const Smach::event& /*x*/)
{
refresh_ducks();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateNormal_Context::event_refresh_tool_options(const Smach::event& x)
+StateNormal_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateNormal_Context::event_stop_handler(const Smach::event& x)
+StateNormal_Context::event_stop_handler(const Smach::event& /*x*/)
{
synfig::info("STATE NORMAL: Received Stop Event");
canvas_view->stop();
}
Smach::event_result
-StateNormal_Context::event_refresh_handler(const Smach::event& x)
+StateNormal_Context::event_refresh_handler(const Smach::event& /*x*/)
{
synfig::info("STATE NORMAL: Received Refresh Event");
canvas_view->rebuild_tables();
}
Smach::event_result
-StateNormal_Context::event_refresh_ducks_handler(const Smach::event& x)
+StateNormal_Context::event_refresh_ducks_handler(const Smach::event& /*x*/)
{
synfig::info("STATE NORMAL: Received Refresh Ducks");
canvas_view->queue_rebuild_ducks();
}
Smach::event_result
-StateNormal_Context::event_undo_handler(const Smach::event& x)
+StateNormal_Context::event_undo_handler(const Smach::event& /*x*/)
{
synfig::info("STATE NORMAL: Received Undo Event");
canvas_view->get_instance()->undo();
}
Smach::event_result
-StateNormal_Context::event_redo_handler(const Smach::event& x)
+StateNormal_Context::event_redo_handler(const Smach::event& /*x*/)
{
synfig::info("STATE NORMAL: Received Redo Event");
canvas_view->get_instance()->redo();
*/
Smach::event_result
-StateNormal_Context::event_multiple_ducks_clicked_handler(const Smach::event& x)
+StateNormal_Context::event_multiple_ducks_clicked_handler(const Smach::event& /*x*/)
{
synfig::info("STATE NORMAL: Received multiple duck click event");
void reset();
void increment_id();
bool no_egress_on_selection_change;
- Smach::event_result event_layer_selection_changed_handler(const Smach::event& x)
+ Smach::event_result event_layer_selection_changed_handler(const Smach::event& /*x*/)
{
if(!no_egress_on_selection_change)
throw Smach::egress_exception();
}
Smach::event_result
-StatePolygon_Context::event_refresh_tool_options(const Smach::event& x)
+StatePolygon_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StatePolygon_Context::event_stop_handler(const Smach::event& x)
+StatePolygon_Context::event_stop_handler(const Smach::event& /*x*/)
{
synfig::info("STATE RotoPolygon: Received Stop Event");
//throw Smach::egress_exception();
}
Smach::event_result
-StatePolygon_Context::event_refresh_handler(const Smach::event& x)
+StatePolygon_Context::event_refresh_handler(const Smach::event& /*x*/)
{
synfig::info("STATE RotoPolygon: Received Refresh Event");
refresh_ducks();
void reset();
void increment_id();
bool no_egress_on_selection_change;
- Smach::event_result event_layer_selection_changed_handler(const Smach::event& x)
+ Smach::event_result event_layer_selection_changed_handler(const Smach::event& /*x*/)
{
if(!no_egress_on_selection_change)
throw Smach::egress_exception();
}
Smach::event_result
-StateRectangle_Context::event_refresh_tool_options(const Smach::event& x)
+StateRectangle_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateRectangle_Context::event_stop_handler(const Smach::event& x)
+StateRectangle_Context::event_stop_handler(const Smach::event& /*x*/)
{
throw Smach::egress_exception();
}
Smach::event_result
-StateRectangle_Context::event_refresh_handler(const Smach::event& x)
+StateRectangle_Context::event_refresh_handler(const Smach::event& /*x*/)
{
refresh_ducks();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateRotate_Context::event_refresh_tool_options(const Smach::event& x)
+StateRotate_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateScale_Context::event_refresh_tool_options(const Smach::event& x)
+StateScale_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateSketch_Context::event_refresh_tool_options(const Smach::event& x)
+StateSketch_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateSketch_Context::event_yield_tool_options(const Smach::event& x)
+StateSketch_Context::event_yield_tool_options(const Smach::event& /*x*/)
{
yield_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateSketch_Context::event_stop_handler(const Smach::event& x)
+StateSketch_Context::event_stop_handler(const Smach::event& /*x*/)
{
throw Smach::egress_exception();
}
Smach::event_result
-StateSketch_Context::event_refresh_handler(const Smach::event& x)
+StateSketch_Context::event_refresh_handler(const Smach::event& /*x*/)
{
return Smach::RESULT_ACCEPT;
}
}
Smach::event_result
-StateSmoothMove_Context::event_refresh_tool_options(const Smach::event& x)
+StateSmoothMove_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateStroke_Context::event_refresh_tool_options(const Smach::event& x)
+StateStroke_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateStroke_Context::event_stop_handler(const Smach::event& x)
+StateStroke_Context::event_stop_handler(const Smach::event& /*x*/)
{
throw Smach::pop_exception();
}
Smach::event_result
-StateStroke_Context::event_refresh_handler(const Smach::event& x)
+StateStroke_Context::event_refresh_handler(const Smach::event& /*x*/)
{
return Smach::RESULT_ACCEPT;
}
}
Smach::event_result
-StateWidth_Context::event_refresh_tool_options(const Smach::event& x)
+StateWidth_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateWidth_Context::event_stop_handler(const Smach::event& x)
+StateWidth_Context::event_stop_handler(const Smach::event& /*x*/)
{
throw Smach::egress_exception();
}
Smach::event_result
-StateWidth_Context::event_refresh_handler(const Smach::event& x)
+StateWidth_Context::event_refresh_handler(const Smach::event& /*x*/)
{
refresh_ducks();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateZoom_Context::event_refresh_tool_options(const Smach::event& x)
+StateZoom_Context::event_refresh_tool_options(const Smach::event& /*x*/)
{
refresh_tool_options();
return Smach::RESULT_ACCEPT;
}
Smach::event_result
-StateZoom_Context::event_stop_handler(const Smach::event& x)
+StateZoom_Context::event_stop_handler(const Smach::event& /*x*/)
{
throw Smach::egress_exception();
}
Smach::event_result
-StateZoom_Context::event_refresh_handler(const Smach::event& x)
+StateZoom_Context::event_refresh_handler(const Smach::event& /*x*/)
{
return Smach::RESULT_ACCEPT;
}
}
void
-Toolbox::on_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& selection_data_, guint info, guint time)
+Toolbox::on_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int /*x*/, int /*y*/, const Gtk::SelectionData& selection_data_, guint /*info*/, guint time)
{
// We will make this true once we have a solid drop
bool success(false);
protected:
//stuff I don't want
- virtual bool set_link_vfunc(int i,synfig::ValueNode::Handle x) {return false;}
+ virtual bool set_link_vfunc(int /*i*/,synfig::ValueNode::Handle /*x*/) {return false;}
virtual LinkableValueNode* create_new()const {return 0;}
//new stuff I need
}
bool
-Widget_Color::redraw(GdkEventExpose*bleh)
+Widget_Color::redraw(GdkEventExpose */*bleh*/)
{
//Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(get_window()));
}
bool
-ColorSlider::redraw(GdkEventExpose*bleh)
+ColorSlider::redraw(GdkEventExpose */*bleh*/)
{
Color color(color_);
}
bool
-Widget_Curves::redraw(GdkEventExpose*bleh)
+Widget_Curves::redraw(GdkEventExpose */*bleh*/)
{
const int h(get_height());
const int w(get_width());
}
bool
- redraw(GdkEventExpose*bleh)
+ redraw(GdkEventExpose */*bleh*/)
{
Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(get_window()));
#define CONTROL_HEIGHT 16
bool
-Widget_Gradient::redraw(GdkEventExpose*bleh)
+Widget_Gradient::redraw(GdkEventExpose */*bleh*/)
{
const int h(get_height());
const int w(get_width());
on_expose_event();
}
-bool studio::Widget_Sound::on_expose_event(GdkEventExpose *heh)
+bool studio::Widget_Sound::on_expose_event(GdkEventExpose */*heh*/)
{
if(!get_window()) return false;
}
}*/
-bool Widget_Timeslider::redraw(bool doublebuffer)
+bool Widget_Timeslider::redraw(bool /*doublebuffer*/)
{
Glib::RefPtr<Gdk::Window> window = get_window();
virtual bool on_button_press_event(GdkEventButton *event); //for clicking
virtual bool on_button_release_event(GdkEventButton *event); //for clicking
- virtual bool on_expose_event(GdkEventExpose *event) {redraw(); return true;}//for drawing
+ virtual bool on_expose_event(GdkEventExpose */*event*/) {redraw(); return true;}//for drawing
virtual bool redraw(bool doublebuffer = false);
}
- virtual bool start_frame(synfig::ProgressCallback *cb)
+ virtual bool start_frame(synfig::ProgressCallback */*cb*/)
{
synfig::Mutex::Lock lock(mutex);
}
- virtual bool start_frame(synfig::ProgressCallback *cb)
+ virtual bool start_frame(synfig::ProgressCallback */*cb*/)
{
return true;
}
}
bool
-WorkArea::on_hruler_event(GdkEvent *event)
+WorkArea::on_hruler_event(GdkEvent */*event*/)
{
/*
switch(event->type)
}
bool
-WorkArea::on_vruler_event(GdkEvent *event)
+WorkArea::on_vruler_event(GdkEvent */*event*/)
{
/*
switch(event->type)
}
synfig::Point
-WorkArea::comp_to_screen_coords(synfig::Point pos)const
+WorkArea::comp_to_screen_coords(synfig::Point /*pos*/)const
{
synfig::warning("WorkArea::comp_to_screen_coords: Not yet implemented");
return synfig::Point();
void
WorkAreaRenderer::render_vfunc(
- const Glib::RefPtr<Gdk::Drawable>& window,
- const Gdk::Rectangle& expose_area
+ const Glib::RefPtr<Gdk::Drawable>& /*window*/,
+ const Gdk::Rectangle& /*expose_area*/
)
{
}
bool
WorkAreaRenderer::event_vfunc(
- GdkEvent* event
+ GdkEvent* /*event*/
)
{
return false;
//! This function will throw an Action::Error() on failure
virtual void perform()=0;
- virtual bool set_param(const synfig::String& name, const Param &) { return false; }
+ virtual bool set_param(const synfig::String& /*name*/, const Param &) { return false; }
virtual bool is_ready()const=0;
virtual synfig::String get_name()const =0;
virtual void prepare() { };
- virtual bool set_param(const synfig::String& name, const Param &)const { return false; }
+ virtual bool set_param(const synfig::String& /*name*/, const Param &)const { return false; }
virtual bool is_ready()const { return ready_; }
void set_name(std::string&x) { name_=x; }
void GetSimpleDerivatives(const std::vector<synfig::Point> &f, int left, int right,
std::vector<synfig::Point> &df, int outleft,
- const std::vector<synfig::Real> &di)
+ const std::vector<synfig::Real> &/*di*/)
{
int i1,i2,i;
int offset = 2; //df = 1/2 (f[i+o]-f[i-o])
}
bool
-CanvasInterface::import(const synfig::String &filename, bool copy)
+CanvasInterface::import(const synfig::String &filename, bool /*copy*/)
{
Action::PassiveGrouper group(get_instance().get(),_("Import Image"));
void
-CanvasInterface::auto_export(ValueNode::Handle value_node)
+CanvasInterface::auto_export(ValueNode::Handle /*value_node*/)
{
/*
// Check to see if we are already exported.
}
void
-CanvasInterface::auto_export(const ValueDesc& value_desc)
+CanvasInterface::auto_export(const ValueDesc& /*value_desc*/)
{
// THIS FUNCTION IS DEPRECATED, AND IS NOW A STUB.
#if 0
int get_selected_layer_count()const { return 0; }
LayerList get_selected_layers()const { return LayerList(); }
synfig::Layer::Handle get_selected_layer()const { return 0; }
- void set_selected_layers(const LayerList &layer_list) { return; }
- void set_selected_layer(const synfig::Layer::Handle &layer) { return; }
+ void set_selected_layers(const LayerList &/*layer_list*/) { return; }
+ void set_selected_layer(const synfig::Layer::Handle &/*layer*/) { return; }
void clear_selected_layers() { return; }
int get_selected_children_count()const { return 0; }
ChildrenList get_selected_children()const { return ChildrenList(); }
ChildrenList::value_type get_selected_child()const { return ChildrenList::value_type(); }
- void set_selected_children(const ChildrenList &children_list) { return; }
- void set_selected_child(const ChildrenList::value_type &child) { return; }
+ void set_selected_children(const ChildrenList &/*children_list*/) { return; }
+ void set_selected_child(const ChildrenList::value_type &/*child*/) { return; }
void clear_selected_children() { return; }
int get_selected_layer_parameter_count()const { return 0; }
LayerParamList get_selected_layer_parameters()const { return LayerParamList(); }
LayerParam get_selected_layer_parameter()const { return LayerParam(); }
- void set_selected_layer_parameters(const LayerParamList &layer_param_list) { return; }
- void set_selected_layer_param(const LayerParam &layer_param) { return; }
+ void set_selected_layer_parameters(const LayerParamList &/*layer_param_list*/) { return; }
+ void set_selected_layer_param(const LayerParam &/*layer_param*/) { return; }
void clear_selected_layer_parameters() { return; }
}; // END of class NullSelectionManager
}
bool
-ConsoleUIInterface::amount_complete(int current, int total)
+ConsoleUIInterface::amount_complete(int /*current*/, int /*total*/)
{
return true;
}
class DefaultUIInterface : public UIInterface
{
public:
- Response yes_no(const std::string &title, const std::string &message,Response dflt)
+ Response yes_no(const std::string &/*title*/, const std::string &/*message*/,Response dflt)
{ return dflt; }
- Response yes_no_cancel(const std::string &title, const std::string &message,Response dflt)
+ Response yes_no_cancel(const std::string &/*title*/, const std::string &/*message*/,Response dflt)
{ return dflt; }
- Response ok_cancel(const std::string &title, const std::string &message,Response dflt)
+ Response ok_cancel(const std::string &/*title*/, const std::string &/*message*/,Response dflt)
{ return dflt; }
- bool task(const std::string &task)
+ bool task(const std::string &/*task*/)
{ return true; }
- bool error(const std::string &task)
+ bool error(const std::string &/*task*/)
{ return true; }
- bool warning(const std::string &task)
+ bool warning(const std::string &/*task*/)
{ return true; }
- bool amount_complete(int current, int total)
+ bool amount_complete(int /*current*/, int /*total*/)
{ return true; }
};
class ConfidentUIInterface : public UIInterface
{
public:
- Response yes_no(const std::string &title, const std::string &message,Response dflt)
+ Response yes_no(const std::string &/*title*/, const std::string &/*message*/,Response /*dflt*/)
{ return RESPONSE_YES; }
- Response yes_no_cancel(const std::string &title, const std::string &message,Response dflt)
+ Response yes_no_cancel(const std::string &/*title*/, const std::string &/*message*/,Response /*dflt*/)
{ return RESPONSE_YES; }
- Response ok_cancel(const std::string &title, const std::string &message,Response dflt)
+ Response ok_cancel(const std::string &/*title*/, const std::string &/*message*/,Response /*dflt*/)
{ return RESPONSE_OK; }
- bool task(const std::string &task)
+ bool task(const std::string &/*task*/)
{ return true; }
- bool error(const std::string &task)
+ bool error(const std::string &/*task*/)
{ return true; }
- bool warning(const std::string &task)
+ bool warning(const std::string &/*task*/)
{ return true; }
- bool amount_complete(int current, int total)
+ bool amount_complete(int /*current*/, int /*total*/)
{ return true; }
};
projects / synfig.git / commitdiff