|
|
|
PHAT Reference Manual | |
|---|---|---|---|---|
PhatKnob;
GtkWidget* phat_knob_new (GtkAdjustment *adjustment);
GtkWidget* phat_knob_new_with_range (double value,
double lower,
double upper,
double step);
GtkAdjustment* phat_knob_get_adjustment (PhatKnob *knob);
double phat_knob_get_value (PhatKnob *knob);
void phat_knob_set_value (PhatKnob *knob,
double value);
void phat_knob_set_range (PhatKnob *knob,
double lower,
double upper);
void phat_knob_set_update_policy (PhatKnob *knob,
GtkUpdateType policy);
void phat_knob_set_adjustment (PhatKnob *knob,
GtkAdjustment *adjustment);
void phat_knob_set_log (PhatKnob *knob,
gboolean is_log);
gboolean phat_knob_is_log (PhatKnob *knob);
typedef struct {
GtkWidget widget;
/* The adjustment object that stores the data for this knob */
GtkAdjustment *adjustment;
GtkAdjustment* adjustment_prv;
/* update policy (GTK_UPDATE_[CONTINUOUS/DELAYED/DISCONTINUOUS]) */
guint policy : 2;
gboolean is_log;
/* State of widget (to do with user interaction) */
guint8 state;
gint saved_x, saved_y;
/* ID of update timer, or 0 if none */
guint32 timer;
/* Pixmap for knob */
GdkPixbuf *pixbuf;
GdkBitmap *mask;
GdkGC *mask_gc;
GdkGC *red_gc;
/* Old values from adjustment stored so we know when something changes */
gfloat old_value;
gfloat old_lower;
gfloat old_upper;
} PhatKnob;
GtkWidget* phat_knob_new_with_range (double value, double lower, double upper, double step);
Creates a new PhatKnob. The knob will create a new
GtkAdjustment from value, lower, upper, and step. If these
parameters represent a bogus configuration, the program will
terminate.
value : |
the initial value the new knob should have |
lower : |
the lowest value the new knob will allow |
upper : |
the highest value the new knob will allow |
step : |
increment added or subtracted when turning |
| Returns : | a newly created PhatKnob |
GtkAdjustment* phat_knob_get_adjustment (PhatKnob *knob);
knob : |
|
| Returns : |
double phat_knob_get_value (PhatKnob *knob);
Retrieves the current value of the knob.
knob : |
a PhatKnob |
| Returns : | current value of the knob |
void phat_knob_set_value (PhatKnob *knob, double value);
Sets the current value of the knob. If the value is outside the
range of values allowed by knob, it will be clamped. The knob
emits the "value-changed" signal if the value changes.
knob : |
a PhatKnob |
value : |
a new value for the knob |
void phat_knob_set_range (PhatKnob *knob, double lower, double upper);
Sets the range of allowable values for the knob, and clamps the
knob's current value to be between lower and upper.
knob : |
a PhatKnob |
lower : |
lowest allowable value |
upper : |
highest allowable value |
void phat_knob_set_update_policy (PhatKnob *knob, GtkUpdateType policy);
knob : |
|
policy : |
void phat_knob_set_adjustment (PhatKnob *knob, GtkAdjustment *adjustment);
knob : |
|
adjustment : |
|
|
PHAT Reference Manual | |
|---|
PHAT Reference Manual |
|---|
|
|
|
PHAT Reference Manual | |
|---|
InstallationInstallation — How to build and install PHAT on your system |
If you're familiar with standard tarball compilation and installation procedures, then PHAT won't pose a problem for you. If you're not used to the tarball dance, you'll still probably do just fine if you follow these instructions.
Apart from having a generally sane Linux distribution and build environment, you need to have GTK+-2.0 or greater installed, along with it's development files.
The magic incantantations to build and install PHAT are as follows:
tar -xzvpf phat.tar.gz
cd phat.tar.gz
./configure
make
su
<enter root password>
make install
/sbin/ldconfig
Replace "phat.tar.gz" above with the actual name of the package you downloaded and you should be golden.
|
|
|
PHAT Reference Manual | |
|---|---|---|---|---|
PhatVFanSliderPhatVFanSlider — a vertical fanslider widget for selecting a floating point value from a range |
PhatVFanSlider;
GtkWidget* phat_vfan_slider_new (GtkAdjustment *adjustment);
GtkWidget* phat_vfan_slider_new_with_range (double value,
double lower,
double upper,
double step);
GObject +----GInitiallyUnowned +----GtkObject +----GtkWidget +----PhatFanSlider +----PhatVFanSlider
PhatVFanSlider is a wrapper class for the abstract base PhatFanSlider class. After creating a PhatVFanSlider, you should interact with it using the PhatFanSlider functions.
typedef struct _PhatVFanSlider PhatVFanSlider;
The PhatVFanSlider struct contains private data only, and should be accessed using the functions below.
GtkWidget* phat_vfan_slider_new (GtkAdjustment *adjustment);
Creates a new PhatVFanSlider.
adjustment : |
the GtkAdjustment that the new slider will use |
| Returns : | a newly created PhatVFanSlider |
GtkWidget* phat_vfan_slider_new_with_range (double value, double lower, double upper, double step);
Creates a new PhatVFanSlider. The slider will create a new GtkAdjustment
from value, lower, and upper. If these parameters represent a bogus
configuration, the program will terminate.
value : |
the initial value the new slider should have |
lower : |
the lowest value the new slider will allow |
upper : |
the highest value the new slider will allow |
step : |
increment added or subtracted when sliding |
| Returns : | a newly created PhatVFanSlider |
|
|
|
PHAT Reference Manual | |
|---|---|---|---|---|
PhatHFanSliderPhatHFanSlider — a horizontal fanslider widget for selecting a floating point value from a range |
PhatHFanSlider;
GtkWidget* phat_hfan_slider_new (GtkAdjustment *adjustment);
GtkWidget* phat_hfan_slider_new_with_range (double value,
double lower,
double upper,
double step);
GObject +----GInitiallyUnowned +----GtkObject +----GtkWidget +----PhatFanSlider +----PhatHFanSlider
PhatHFanSlider is a wrapper class for the abstract base PhatFanSlider class. After creating a PhatHFanSlider, you should interact with it using the PhatFanSlider functions.
typedef struct _PhatHFanSlider PhatHFanSlider;
The PhatHFanSlider struct contains private data only, and should be accessed using the functions below.
GtkWidget* phat_hfan_slider_new (GtkAdjustment *adjustment);
Creates a new PhatHFanSlider.
adjustment : |
the GtkAdjustment that the new slider will use |
| Returns : | a newly created PhatHFanSlider |
GtkWidget* phat_hfan_slider_new_with_range (double value, double lower, double upper, double step);
Creates a new PhatHFanSlider. The slider will create a new GtkAdjustment
from value, lower, and upper. If these parameters represent a bogus
configuration, the program will terminate.
value : |
the initial value the new slider should have |
lower : |
the lowest value the new slider will allow |
upper : |
the highest value the new slider will allow |
step : |
increment added or subtracted when sliding |
| Returns : | a newly created PhatHFanSlider |
|
|
|
PHAT Reference Manual | |
|---|---|---|---|---|
PhatHKeyboard;
GtkWidget* phat_hkeyboard_new (GtkAdjustment *adjustment,
int numkeys,
gboolean show_labels);
GObject +----GInitiallyUnowned +----GtkObject +----GtkWidget +----GtkContainer +----GtkBin +----GtkViewport +----PhatKeyboard +----PhatHKeyboard
PhatHKeyboard is a wrapper for the abstract PhatKeyboard class. After creating a PhatHKeyboard, you should interact with it using the PhatKeyboard functions.
typedef struct _PhatHKeyboard PhatHKeyboard;
The PhatHKeyboard struct contains private data only, and should be accessed using the functions below.
GtkWidget* phat_hkeyboard_new (GtkAdjustment *adjustment, int numkeys, gboolean show_labels);
Creates a new PhatHKeyboard.
adjustment : |
the GtkAdjustment that the new keyboard will use for scrolling |
numkeys : |
number of keys to create |
show_labels : |
whether to label the C keys |
| Returns : | a newly created PhatHKeyboard |
|
|
|
PHAT Reference Manual | |
|---|---|---|---|---|
PhatKeyboardPhatKeyboard — a base class for PhatHKeyboard and PhatVKeyboard |
_Key;
PhatKeyboard;
GtkAdjustment* phat_keyboard_get_adjustment (PhatKeyboard *keyboard);
void phat_keyboard_set_adjustment (PhatKeyboard *keyboard,
GtkAdjustment *adjustment);
GObject +----GInitiallyUnowned +----GtkObject +----GtkWidget +----GtkContainer +----GtkBin +----GtkViewport +----PhatKeyboard +----PhatVKeyboard +----PhatHKeyboard
"numkeys" gint : Read / Write / Construct Only "orientation" GtkOrientation : Read / Write / Construct Only "show-labels" gboolean : Read / Write / Construct Only
"key-pressed" void user_function (PhatKeyboard *keyboard, gint key, gpointer user_data) : Run first / Action "key-released" void user_function (PhatKeyboard *keyboard, gint key, gpointer user_data) : Run first / Action
The PhatKeyboard widget family provides a simple piano-like keyboard. Since it is derived from GtkViewport, it comes with the ability to scroll. You don't have to worry about the values of the GtkAdjustment it uses, just share said adjustment with a scrollbar and you'll be in business.
PhatKeyboard is an abstract base class, from which PhatHKeyboard and
PhatVKeyboard are derived. To create a new keyboard, call either
phat_hkeyboard_new() or phat_vkeyboard_new().
typedef struct {
int index;
PhatKeyboard* keyboard; /* the keyboard we belong to */
GnomeCanvasGroup* group; /* the group this key belongs to */
GnomeCanvasItem* pre; /* prelight rectangle */
GnomeCanvasItem* on; /* active (depressed) rectangle */
GnomeCanvasItem* shad; /* active shadow */
} _Key;
typedef struct _PhatKeyboard PhatKeyboard;
The PhatKeyboard struct contains private data only, and should be accessed using the functions below.
GtkAdjustment* phat_keyboard_get_adjustment (PhatKeyboard *keyboard);
Retrives the current adjustment in use by keyboard.
keyboard : |
a PhatKeyboard |
| Returns : | keyboard's current GtkAdjustment
|
void phat_keyboard_set_adjustment (PhatKeyboard *keyboard, GtkAdjustment *adjustment);
Sets the adjustment used by keyboard.
keyboard : |
a PhatKeyboard |
adjustment : |
a GtkAdjustment |
numkeys" property"numkeys" gint : Read / Write / Construct Only
How many keys this keyboard should have.
Allowed values: [1,1000]
Default value: 128
orientation" property"orientation" GtkOrientation : Read / Write / Construct Only
How the keyboard should be arranged on the screen.
Default value: GTK_ORIENTATION_VERTICAL
show-labels" property"show-labels" gboolean : Read / Write / Construct Only
Whether C keys should be labeled or not.
Default value: TRUE
void user_function (PhatKeyboard *keyboard, gint key, gpointer user_data) : Run first / Action
The "key-pressed" signal is emitted whenever a key is pressed.
keyboard : |
the object on which the signal was emitted |
key : |
the index of the key that was pressed |
user_data : |
user data set when the signal handler was connected. |
void user_function (PhatKeyboard *keyboard, gint key, gpointer user_data) : Run first / Action
The "key-released" signal is emitted whenever a key is released.
keyboard : |
the object on which the signal was emitted |
key : |
the index of the key that was pressed |
user_data : |
user data set when the signal handler was connected. |
|
|
|
PHAT Reference Manual | |
|---|
|
|
PHAT Reference Manual | |
|---|
PHAT is a library of GTK+ widgets which are useful for pro-audio apps. The name is a backronym which stands for "the PHat Audio Toolkit."
|
|
|
PHAT Reference Manual | |
|---|---|---|---|---|
PhatVKeyboard;
GtkWidget* phat_vkeyboard_new (GtkAdjustment *adjustment,
int numkeys,
gboolean show_labels);
GObject +----GInitiallyUnowned +----GtkObject +----GtkWidget +----GtkContainer +----GtkBin +----GtkViewport +----PhatKeyboard +----PhatVKeyboard
PhatVKeyboard is a wrapper for the abstract PhatKeyboard class. After creating a PhatVKeyboard, you should interact with it using the PhatKeyboard functions.
typedef struct _PhatVKeyboard PhatVKeyboard;
The PhatVKeyboard struct contains private data only, and should be accessed using the functions below.
GtkWidget* phat_vkeyboard_new (GtkAdjustment *adjustment, int numkeys, gboolean show_labels);
Creates a new PhatVKeyboard.
adjustment : |
the GtkAdjustment that the new keyboard will use for scrolling |
numkeys : |
number of keys to create |
show_labels : |
whether to label the C keys |
| Returns : | a newly created PhatVKeyboard |
|
|
|
PHAT Reference Manual | |
|---|---|---|---|---|
PhatSliderButton;
GtkWidget* phat_slider_button_new (GtkAdjustment *adjustment,
int digits);
GtkWidget* phat_slider_button_new_with_range
(double value,
double lower,
double upper,
double step,
int digits);
void phat_slider_button_set_value (PhatSliderButton *button,
double value);
double phat_slider_button_get_value (PhatSliderButton *button);
void phat_slider_button_set_range (PhatSliderButton *button,
double lower,
double upper);
void phat_slider_button_get_range (PhatSliderButton *button,
double *lower,
double *upper);
void phat_slider_button_set_adjustment
(PhatSliderButton *button,
GtkAdjustment *adjustment);
GtkAdjustment* phat_slider_button_get_adjustment
(PhatSliderButton *button);
void phat_slider_button_set_increment
(PhatSliderButton *button,
double step,
double page);
void phat_slider_button_get_increment
(PhatSliderButton *button,
double *step,
double *page);
void phat_slider_button_set_format (PhatSliderButton *button,
int digits,
const char *prefix,
const char *postfix);
void phat_slider_button_get_format (PhatSliderButton *button,
int *digits,
char **prefix,
char **postfix);
void phat_slider_button_set_threshold
(PhatSliderButton *button,
guint threshold);
int phat_slider_button_get_threshold
(PhatSliderButton *button);
GObject +----GInitiallyUnowned +----GtkObject +----GtkWidget +----GtkContainer +----GtkBox +----GtkHBox +----PhatSliderButton
"changed" void user_function (PhatSliderButton *button, gpointer user_data) : Run first / Action "value-changed" void user_function (PhatSliderButton *button, gpointer user_data) : Run first / Action
A PhatSliderButton can be used in place of a GtkSpinButton. It's a better choice than a PhatFanSlider when you want the user to clearly see the value they are setting, or want to constrain their selection to a set of discrete values (fansliders are "continuous").
Sliderbuttons allow the user to change the value by grabbing the widget and dragging. They can also make small "one off" adjustments via the arrow buttons, or click the button to enter the value directly. They have a slightly higher learning curve than standard spinbuttons, but they offer much more efficiency to the user.
The way the current value of a sliderbutton is displayed is controlled
with a printf style format specifier supplied at widget creation.
Since sliderbuttons operate with doubles, the specifier should be in
the form of "%f" or any of the other double compatible printf escapes.
You should resist the urge to embed other information in the format
specifier, since that extra text will also wind up in the entry when
the user clicks the button. Instead, use
phat_slider_button_set_format() to set prefix and/or postfix text.
typedef struct _PhatSliderButton PhatSliderButton;
The PhatSliderButton struct contains private data only, and should be accessed using the functions below.
GtkWidget* phat_slider_button_new (GtkAdjustment *adjustment, int digits);
Creates a new PhatSliderButton.
adjustment : |
the GtkAdjustment that the new button will use |
digits : |
number of decimal digits to display |
| Returns : | a newly created PhatSliderButton |
GtkWidget* phat_slider_button_new_with_range (double value, double lower, double upper, double step, int digits);
Creates a new PhatSliderButton. The slider will create a new
GtkAdjustment from value, lower, upper, and step. If these
parameters represent a bogus configuration, the program will
terminate.
value : |
the initial value the new button should have |
lower : |
the lowest value the new button will allow |
upper : |
the highest value the new button will allow |
step : |
increment added or subtracted when sliding |
digits : |
number of decimal digits to display |
| Returns : | a newly created PhatSliderButton |
void phat_slider_button_set_value (PhatSliderButton *button, double value);
Sets the current value of the button. If the value is outside the
range of values allowed by button, it will be clamped. The button
emits the "value-changed" signal if the value changes.
button : |
a PhatSliderButton |
value : |
a new value for the button |
double phat_slider_button_get_value (PhatSliderButton *button);
Retrieves the current value of the button.
button : |
a PhatSliderButton |
| Returns : | current value of the button |
void phat_slider_button_set_range (PhatSliderButton *button, double lower, double upper);
Sets the range of allowable values for the button, and clamps the
button's current value to be between lower and upper.
button : |
a PhatSliderButton |
lower : |
lowest allowable value |
upper : |
highest allowable value |
void phat_slider_button_get_range (PhatSliderButton *button, double *lower, double *upper);
Places the range of allowable values for button into lower
and upper. Either variable may be set to NULL if you are not
interested in its value.
button : |
a PhatSliderButton |
lower : |
retrieves lowest allowable value |
upper : |
retrieves highest allowable value |
void phat_slider_button_set_adjustment
(PhatSliderButton *button,
GtkAdjustment *adjustment);
Sets the adjustment used by button. If adjustment is NULL, a
new adjustment with a value of zero and a range of [-1.0, 1.0] will
be created.
button : |
a PhatSliderButton |
adjustment : |
a GtkAdjustment |
GtkAdjustment* phat_slider_button_get_adjustment (PhatSliderButton *button);
Retrives the current adjustment in use by button.
button : |
a PhatSliderButton |
| Returns : | button's current GtkAdjustment
|
void phat_slider_button_set_increment
(PhatSliderButton *button,
double step,
double page);
Sets the increments the button should use.
button : |
a PhatSliderButton |
step : |
step increment value |
page : |
page increment value |
void phat_slider_button_get_increment
(PhatSliderButton *button,
double *step,
double *page);
Places the button's increment values into step and page. Either
variable may be set to NULL if you are not interested in its
value.
button : |
a PhatSliderButton |
step : |
retrieves step increment value |
page : |
retrieves page increment value |
void phat_slider_button_set_format (PhatSliderButton *button, int digits, const char *prefix, const char *postfix);
Sets the way button renders it's label. If the first character in
either prefix or postfix is '\0' the corresponding parameter will
be unset. If you don't want to adjust digits, set it to a
negative value. If you don't want to adjust prefix and/or
postfix, set them to NULL.
button : |
a PhatSliderButton |
digits : |
number of decimal digits to display |
prefix : |
text to prepend to number |
postfix : |
text to append to number |
void phat_slider_button_get_format (PhatSliderButton *button, int *digits, char **prefix, char **postfix);
Retrieves the information button uses to create its label. The
value returned will point to the button's local copy, so don't
write to it. Set the pointers for any value you aren't interested
in to NULL.
button : |
a PhatSliderButton |
digits : |
retrieves the number of decimal digits to display |
prefix : |
retrieves text prepended to number |
postfix : |
retrieves text appended to number |
void phat_slider_button_set_threshold
(PhatSliderButton *button,
guint threshold);
Sets the threshold for button. The threshold is how far the user
has to move the mouse to effect a change when sliding.
button : |
a PhatSliderButton |
threshold : |
an unsigned int >= 1 |
int phat_slider_button_get_threshold
(PhatSliderButton *button);
Retrieves the threshold for button
button : |
a PhatSliderButton |
| Returns : | the threshold for button, or -1 if button is invalid
|
void user_function (PhatSliderButton *button, gpointer user_data) : Run first / Action
The "changed" signal is emitted when any parameter of the
slider's adjustment changes, except for the value parameter.
button : |
the object on which the signal was emitted |
user_data : |
user data set when the signal handler was connected. |
void user_function (PhatSliderButton *button, gpointer user_data) : Run first / Action
The "value-changed" signal is emitted when the value of the button's adjustment changes.
button : |
the object on which the signal was emitted |
user_data : |
user data set when the signal handler was connected. |
|
|
|
PHAT Reference Manual | |
|---|---|---|---|---|
PhatFanSliderPhatFanSlider — a base class for PhatHFanSlider and PhatVFanSlider |
PhatFanSlider;
void phat_fan_slider_set_value (PhatFanSlider *slider,
double value);
void phat_fan_slider_set_log (PhatFanSlider *slider,
gboolean is_log);
gboolean phat_fan_slider_is_log (PhatFanSlider *slider);
double phat_fan_slider_get_value (PhatFanSlider *slider);
void phat_fan_slider_set_range (PhatFanSlider *slider,
double lower,
double upper);
void phat_fan_slider_get_range (PhatFanSlider *slider,
double *lower,
double *upper);
void phat_fan_slider_set_adjustment (PhatFanSlider *slider,
GtkAdjustment *adjustment);
GtkAdjustment* phat_fan_slider_get_adjustment
(PhatFanSlider *slider);
void phat_fan_slider_set_inverted (PhatFanSlider *slider,
gboolean inverted);
gboolean phat_fan_slider_get_inverted (PhatFanSlider *slider);
void phat_fan_slider_set_default_value
(PhatFanSlider *slider,
gdouble value);
GObject +----GInitiallyUnowned +----GtkObject +----GtkWidget +----PhatFanSlider +----PhatVFanSlider +----PhatHFanSlider
"changed" void user_function (PhatFanSlider *slider, gpointer user_data) : Run first / Action "value-changed" void user_function (PhatFanSlider *slider, gpointer user_data) : Run first / Action
The PhatFanSlider widget family provides a slider widget for retrieving floating point values from the user. The cool thing about fansliders is that the user can have a great amount of precision in a very small space. After depressing the left mouse button on a fanslider, the user can then drag the pointer away from the widget, causing a "fan" to popup which indicates the new scale they are working with. The farther out the pointer is drawn, the greater the size of the fan and the level of precision.
The fansliders work like most other numerical entry widgets; if you know how to use a GtkSpinbutton, you know how to use a PhatFanSlider. If not, check out the GTK+-2.0 tutorial.
You can change the colors that a given fanslider uses. Fansliders use widget->style->base_gc[GTK_STATE_SELECTED] for the foreground color, and widget->style->dark_gc[GTK_STATE_NORMAL] for the background color. Adjusting these elements of the widget's style will change the way the fanslider draws.
PhatFanSlider is an abstract base class, from which PhatHFanSlider and
PhatVFanSlider are derived. To create a new fanslider, call either
phat_vfanslider_new() or phat_hfanslider_new().
typedef struct _PhatFanSlider PhatFanSlider;
The PhatFanSlider struct contains private data only, and should be accessed using the functions below.
void phat_fan_slider_set_value (PhatFanSlider *slider, double value);
Sets the current value of the slider. If the value is outside the
range of values allowed by slider, it will be clamped to fit
within them. The slider emits the "value-changed" signal if the
value changes.
slider : |
a PhatFanSlider |
value : |
a new value for the slider |
void phat_fan_slider_set_log (PhatFanSlider *slider, gboolean is_log);
slider : |
|
is_log : |
gboolean phat_fan_slider_is_log (PhatFanSlider *slider);
slider : |
|
| Returns : |
double phat_fan_slider_get_value (PhatFanSlider *slider);
Retrieves the current value of the slider.
slider : |
a PhatFanSlider |
| Returns : | current value of the slider. |
void phat_fan_slider_set_range (PhatFanSlider *slider, double lower, double upper);
Sets the range of allowable values for the slider, and clamps the slider's
current value to be between lower and upper.
slider : |
a PhatFanSlider |
lower : |
lowest allowable value |
upper : |
highest allowable value |
void phat_fan_slider_get_range (PhatFanSlider *slider, double *lower, double *upper);
Places the range of allowable values for slider into lower
and upper. Either variable may be set to NULL if you are not
interested in its value.
slider : |
a PhatFanSlider |
lower : |
retrieves lowest allowable value |
upper : |
retrieves highest allowable value |
void phat_fan_slider_set_adjustment (PhatFanSlider *slider, GtkAdjustment *adjustment);
Sets the adjustment used by slider. Every PhatFanSlider uses an
adjustment to store its current value and its range of allowable
values. If adjustment is NULL, a new adjustment with a value of
zero and a range of [-1.0, 1.0] will be created.
slider : |
a PhatFanSlider |
adjustment : |
a GtkAdjustment |
GtkAdjustment* phat_fan_slider_get_adjustment (PhatFanSlider *slider);
Retrives the current adjustment in use by slider.
slider : |
a PhatFanSlider |
| Returns : | slider's current GtkAdjustment
|
void phat_fan_slider_set_inverted (PhatFanSlider *slider, gboolean inverted);
Sets in which direction the fanslider should draw increasing
values. By default, horizontal fansliders draw low to high from
left to right, and vertical fansliders draw from bottom to top.
You can reverse this behavior by setting inverted to TRUE.
slider : |
a PhatFanSlider |
inverted : |
TRUE to invert the fanslider
|
gboolean phat_fan_slider_get_inverted (PhatFanSlider *slider);
Determines whether slider is inverted or not.
slider : |
a PhatFanSlider |
| Returns : | TRUE if slider is inverted
|
void phat_fan_slider_set_default_value
(PhatFanSlider *slider,
gdouble value);
Set default value of the slider. Slider is reset to this value when middle mouse button is pressed.
slider : |
a PhatFanSlider |
value : |
the default value |
void user_function (PhatFanSlider *slider, gpointer user_data) : Run first / Action
The "changed" signal is emitted when any parameter of the
slider's adjustment changes, except for the value parameter.
slider : |
the object on which the signal was emitted |
user_data : |
user data set when the signal handler was connected. |
void user_function (PhatFanSlider *slider, gpointer user_data) : Run first / Action
The "value-changed" signal is emitted when the value of the slider's adjustment changes.
slider : |
the object on which the signal was emitted |
user_data : |
user data set when the signal handler was connected. |
|
|
|
PHAT Reference Manual | |
|---|---|---|---|---|
PhatPad;
GtkWidget* phat_pad_new ();
GtkAdjustment* phat_pad_get_ytilt (PhatPad *pad);
GtkAdjustment* phat_pad_get_xtilt (PhatPad *pad);
GtkAdjustment* phat_pad_get_pressure (PhatPad *pad);
GtkAdjustment* phat_pad_get_y (PhatPad *pad);
GtkAdjustment* phat_pad_get_x (PhatPad *pad);
void phat_pad_set_x_range (PhatPad *pad,
gdouble min,
gdouble max);
void phat_pad_set_y_range (PhatPad *pad,
gdouble min,
gdouble max);
void phat_pad_set_pressure_range (PhatPad *pad,
gdouble min,
gdouble max);
void phat_pad_set_x_log (PhatPad *pad,
gboolean is_log);
void phat_pad_set_y_log (PhatPad *pad,
gboolean is_log);
void phat_pad_set_xtilt_log (PhatPad *pad,
gboolean is_log);
void phat_pad_set_ytilt_log (PhatPad *pad,
gboolean is_log);
void phat_pad_set_pressure_log (PhatPad *pad,
gboolean is_log);
gboolean phat_pad_x_is_log (PhatPad *pad);
gboolean phat_pad_y_is_log (PhatPad *pad);
gboolean phat_pad_xtilt_is_log (PhatPad *pad);
gboolean phat_pad_ytilt_is_log (PhatPad *pad);
gboolean phat_pad_pressure_is_log (PhatPad *pad);
typedef struct {
GtkDrawingArea parent;
GdkPixmap* pixmap;
GtkAdjustment* pressure;
gboolean p_is_log;
GtkAdjustment* xtilt;
gboolean xt_is_log;
GtkAdjustment* ytilt;
gboolean yt_is_log;
GtkAdjustment* x;
gboolean x_is_log;
GtkAdjustment* y;
gboolean y_is_log;
} PhatPad;
GtkWidget* phat_pad_new ();
Creates a new PhatPad.
| Returns : | a newly created PhatPad |
GtkAdjustment* phat_pad_get_ytilt (PhatPad *pad);
Retrieves the current ytilt value of the pad.
pad : |
a PhatPad |
| Returns : | current ytilt value. |
GtkAdjustment* phat_pad_get_xtilt (PhatPad *pad);
Retrieves the current xtilt value of the pad.
pad : |
a PhatPad |
| Returns : | current xtilt value. |
GtkAdjustment* phat_pad_get_pressure (PhatPad *pad);
Retrieves the current pressure value of the pad.
pad : |
a PhatPad |
| Returns : | current pressure value. |
GtkAdjustment* phat_pad_get_y (PhatPad *pad);
Retrieves the current y value of the pad.
pad : |
a PhatPad |
| Returns : | current y value. |
GtkAdjustment* phat_pad_get_x (PhatPad *pad);
Retrieves the current x value of the pad.
pad : |
a PhatPad |
| Returns : | current x value. |
void phat_pad_set_x_range (PhatPad *pad, gdouble min, gdouble max);
Sets the x range of the pad.
pad : |
a PhatPad |
min : |
|
max : |
void phat_pad_set_y_range (PhatPad *pad, gdouble min, gdouble max);
pad : |
|
min : |
|
max : |
void phat_pad_set_pressure_range (PhatPad *pad, gdouble min, gdouble max);
pad : |
|
min : |
|
max : |
void phat_pad_set_xtilt_log (PhatPad *pad, gboolean is_log);
pad : |
|
is_log : |
void phat_pad_set_ytilt_log (PhatPad *pad, gboolean is_log);
pad : |
|
is_log : |
void phat_pad_set_pressure_log (PhatPad *pad, gboolean is_log);
pad : |
|
is_log : |