forked from mia/Aegisub
277 lines
8.1 KiB
C++
277 lines
8.1 KiB
C++
// Copyright (c) 2007, Patryk Pomykalski
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
// * Neither the name of the Aegisub Group nor the names of its contributors
|
|
// may be used to endorse or promote products derived from this software
|
|
// without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// AEGISUB
|
|
//
|
|
// Website: http://aegisub.cellosoft.com
|
|
// Contact: mailto:pomyk@go2.pl
|
|
//
|
|
|
|
#pragma once
|
|
|
|
#ifndef _AUTO4_RUBY_H
|
|
#define _AUTO4_RUBY_H
|
|
|
|
#pragma warning(disable: 4311 4312)
|
|
|
|
#include "auto4_base.h"
|
|
#include <wx/thread.h>
|
|
#include <wx/event.h>
|
|
#include <ruby.h>
|
|
|
|
class wxWindow;
|
|
|
|
namespace Automation4 {
|
|
|
|
|
|
// Provides access to an AssFile object (and all lines contained) for a Ruby script
|
|
class RubyAssFile {
|
|
private:
|
|
AssFile *ass;
|
|
|
|
bool can_modify;
|
|
bool can_set_undo;
|
|
|
|
// keep a cursor of last accessed item to avoid walking over the entire file on every access
|
|
std::list<AssEntry*>::iterator last_entry_ptr;
|
|
int last_entry_id;
|
|
|
|
static int RubyParseTagData();
|
|
static int RubyUnparseTagData();
|
|
static int RubySetUndoPoint();
|
|
|
|
public:
|
|
void RubyUpdateAssFile(VALUE subtitles);
|
|
static VALUE AssEntryToRuby(AssEntry *e); // makes a Ruby representation of AssEntry
|
|
static AssEntry *RubyToAssEntry(VALUE ass_entry); // creates an AssEntry object from a Ruby representation
|
|
RubyAssFile(AssFile *_ass, bool _can_modify, bool _can_set_undo);
|
|
~RubyAssFile();
|
|
|
|
static RubyAssFile *raf;
|
|
VALUE rbAssFile;
|
|
|
|
};
|
|
|
|
|
|
// Provides progress UI and control functions for a Ruby script
|
|
class RubyProgressSink : public ProgressSink {
|
|
private:
|
|
|
|
public:
|
|
RubyProgressSink(wxWindow *parent, bool allow_config_dialog = true);
|
|
virtual ~RubyProgressSink();
|
|
static RubyProgressSink* inst;
|
|
static VALUE RubySetProgress(VALUE self, VALUE progress);
|
|
static VALUE RubySetTask(VALUE self, VALUE task);
|
|
static VALUE RubySetTitle(VALUE self, VALUE title);
|
|
static VALUE RubyGetCancelled(VALUE self);
|
|
static VALUE RubyDebugOut(int argc, VALUE *args, VALUE self);
|
|
static VALUE RubyDisplayDialog(VALUE self, VALUE cfg, VALUE buttons);
|
|
};
|
|
|
|
|
|
// Provides Config UI functions for a Ruby script
|
|
class RubyConfigDialogControl {
|
|
public:
|
|
wxControl *cw; // control window
|
|
wxString name, hint;
|
|
int x, y, width, height;
|
|
VALUE name_sym;
|
|
|
|
virtual wxControl *Create(wxWindow *parent) = 0;
|
|
virtual void ControlReadBack() = 0;
|
|
virtual VALUE RubyReadBack() = 0;
|
|
|
|
RubyConfigDialogControl();
|
|
RubyConfigDialogControl(VALUE opts);
|
|
virtual ~RubyConfigDialogControl() { }
|
|
};
|
|
|
|
class RubyConfigDialog : public ScriptConfigDialog {
|
|
private:
|
|
std::vector<RubyConfigDialogControl*> controls;
|
|
std::vector<wxString> buttons;
|
|
bool use_buttons;
|
|
|
|
class ButtonEventHandler : public wxEvtHandler {
|
|
public:
|
|
int *button_pushed;
|
|
void OnButtonPush(wxCommandEvent &evt);
|
|
};
|
|
|
|
ButtonEventHandler *button_event;
|
|
int button_pushed;
|
|
|
|
protected:
|
|
wxWindow* CreateWindow(wxWindow *parent);
|
|
|
|
public:
|
|
RubyConfigDialog(VALUE cfg, VALUE buttons, bool show_buttons);
|
|
virtual ~RubyConfigDialog();
|
|
VALUE RubyReadBack(); // read back internal structure to Ruby hash
|
|
|
|
void ReadBack(); // from auto4 base
|
|
};
|
|
|
|
|
|
// Second base-class for Ruby implemented Features
|
|
class RubyFeature : public virtual Feature {
|
|
protected:
|
|
|
|
int myid;
|
|
|
|
RubyFeature(ScriptFeatureClass _featureclass, const wxString &_name);
|
|
|
|
void RegisterFeature();
|
|
VALUE CreateIntegerArray(const std::vector<int> &ints);
|
|
void ThrowError();
|
|
};
|
|
|
|
|
|
// Class of Ruby scripts
|
|
class RubyScript : public Script {
|
|
friend class RubyFeature;
|
|
friend class RubyProgressSink;
|
|
|
|
private:
|
|
|
|
void Create(); // load script and create internal structures etc.
|
|
void Destroy(); // destroy internal structures, unreg features and delete environment
|
|
|
|
static RubyScript* GetScriptObject();
|
|
public:
|
|
static VALUE RubyTextExtents(VALUE self, VALUE style, VALUE text);
|
|
static VALUE RubyFrameToTime(VALUE self, VALUE frame);
|
|
static VALUE RubyTimeToFrame(VALUE self, VALUE time);
|
|
static VALUE RubyKeyFrames(VALUE self);
|
|
static VALUE backtrace_hook(VALUE self, VALUE backtr);
|
|
|
|
RubyScript(const wxString &filename);
|
|
static void RubyError();
|
|
static wxString GetError();
|
|
virtual ~RubyScript();
|
|
virtual void Reload();
|
|
static RubyScript* inst;
|
|
};
|
|
|
|
|
|
// Implementation of the Macro Feature for Ruby scripts
|
|
class RubyFeatureMacro : public FeatureMacro, RubyFeature {
|
|
private:
|
|
bool no_validate;
|
|
VALUE macro_fun;
|
|
VALUE validation_fun;
|
|
|
|
protected:
|
|
RubyFeatureMacro(const wxString &_name, const wxString &_description, VALUE macro_function, VALUE validate_function);
|
|
public:
|
|
static VALUE RubyRegister(VALUE self, VALUE name, VALUE description, VALUE macro_function, VALUE validate_function);
|
|
virtual ~RubyFeatureMacro() { }
|
|
|
|
virtual bool Validate(AssFile *subs, const std::vector<int> &selected, int active);
|
|
virtual void Process(AssFile *subs, const std::vector<int> &selected, int active, wxWindow * const progress_parent);
|
|
};
|
|
|
|
|
|
// Implementation of the Export Filter Feature for Ruby scripts
|
|
class RubyFeatureFilter : public FeatureFilter, RubyFeature {
|
|
private:
|
|
bool has_config;
|
|
RubyConfigDialog *config_dialog;
|
|
VALUE filter_fun;
|
|
VALUE dialog_fun;
|
|
|
|
protected:
|
|
RubyFeatureFilter(const wxString &_name, const wxString &_description, int merit, VALUE function, VALUE dialog);
|
|
|
|
ScriptConfigDialog* GenerateConfigDialog(wxWindow *parent);
|
|
|
|
void Init();
|
|
public:
|
|
static VALUE RubyRegister(VALUE self, VALUE name, VALUE description, VALUE merit, VALUE macro_function, VALUE validate_function);
|
|
|
|
void ProcessSubs(AssFile *subs, wxWindow *export_dialog);
|
|
};
|
|
|
|
// class for registering ruby objects created in c++
|
|
// so garbage collector doesn't destroy them
|
|
class RubyObjects {
|
|
private:
|
|
VALUE objects;
|
|
static RubyObjects *inst;
|
|
RubyObjects();
|
|
public:
|
|
~RubyObjects();
|
|
static RubyObjects *Get();
|
|
void Register(VALUE object);
|
|
void Unregister(VALUE object);
|
|
};
|
|
|
|
// stuff for safe calling of ruby functions
|
|
struct RubyCallArguments {
|
|
VALUE recv;
|
|
ID id;
|
|
int n;
|
|
VALUE *argv;
|
|
RubyCallArguments(VALUE _recv, ID _id, int _n, VALUE *_argv);
|
|
};
|
|
|
|
// Separate thread for ruby interpreter
|
|
class RubyThread : public wxThread {
|
|
private:
|
|
enum {NOTHING, CALL_FUNCTION, LOAD_FILE};
|
|
int action;
|
|
int status;
|
|
RubyCallArguments *args;
|
|
const char* file;
|
|
VALUE *result;
|
|
void InitRuby();
|
|
wxPathList include_path;
|
|
public:
|
|
RubyThread(wxPathList include_path);
|
|
void CallFunction(RubyCallArguments* arg, VALUE *res);
|
|
void LoadFile(const char* file);
|
|
int GetStatus() {return status;};
|
|
virtual ExitCode Entry();
|
|
};
|
|
|
|
VALUE rbCallWrapper(VALUE arg);
|
|
VALUE rbExecWrapper(VALUE arg);
|
|
VALUE rbLoadWrapper(VALUE arg);
|
|
VALUE rbGcWrapper(VALUE arg);
|
|
VALUE rbAss2RbWrapper(VALUE arg);
|
|
VALUE rb2AssWrapper(VALUE arg);
|
|
VALUE rbError(VALUE arg);
|
|
typedef VALUE (*RB_HOOK)(...);
|
|
typedef VALUE (*RB_HOOK2)(VALUE);
|
|
|
|
#define STR2SYM(x) ID2SYM(rb_intern(x))
|
|
};
|
|
|
|
#endif
|