ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

onepad: Switch to the new dialog code and remove the old code. 

git-svn-id: http://pcsx2.googlecode.com/svn/trunk@3164 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
arcum42 2010-06-05 08:22:14 +00:00
parent d51d36d65f
commit d39bdfcd1e
14 changed files with 218 additions and 2941 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
plugins/onepad/CMakeLists.txt
View File

@ -35,7 +35,6 @@ endif(CMAKE_BUILD_TYPE STREQUAL Release)
set(onepadSources
analog.cpp
controller.cpp
dialog.cpp
joystick.cpp
keyboard.cpp
onepad.cpp)
@ -51,18 +50,13 @@ set(onepadHeaders
# onepad Linux sources
set(onepadLinuxSources
# Linux/callbacks.c
Linux/gui.cpp
Linux/ini.cpp
Linux/interface.c
Linux/linux.cpp
Linux/support.c)
Linux/dialog.cpp
Linux/linux.cpp)
# onepad Linux headers
set(onepadLinuxHeaders
Linux/callbacks.h
Linux/interface.h
Linux/support.h)
Linux/linux.h)
# onepad Windows sources
set(onepadWindowsSources

10
plugins/onepad/Linux/OnePad.cbp
View File

@ -48,21 +48,11 @@
<Add option="`pkg-config sdl --libs`" />
<Add option="-shared" />
</Linker>
<Unit filename="callbacks.h" />
<Unit filename="dialog.cpp" />
<Unit filename="gui.cpp" />
<Unit filename="ini.cpp" />
<Unit filename="interface.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="interface.h" />
<Unit filename="linux.cpp" />
<Unit filename="linux.h" />
<Unit filename="onepad.glade" />
<Unit filename="support.c">
<Option compilerVar="CC" />
</Unit>
<Unit filename="support.h" />
<Unit filename="../analog.cpp" />
<Unit filename="../analog.h" />
<Unit filename="../bitwise.h" />

139
plugins/onepad/Linux/callbacks.c
View File

@ -1,139 +0,0 @@
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <gtk/gtk.h>
#include "callbacks.h"
#include "interface.h"
#include "support.h"
void
OnAbout_Ok (GtkDialog *dialog,
gint response_id,
gpointer user_data)
{
}
void
OnConf_Pad1 (GtkButton *button,
gpointer user_data)
{
}
void
OnConf_Pad2 (GtkButton *button,
gpointer user_data)
{
}
void
OnConf_Pad3 (GtkButton *button,
gpointer user_data)
{
}
void
OnConf_Pad4 (GtkButton *button,
gpointer user_data)
{
}
void
on_joydevicescombo_changed (GtkComboBox *combobox,
gpointer user_data)
{
}
void
OnConf_Key (GtkButton *button,
gpointer user_data)
{
}
void
on_checkbutton_reverselx_toggled (GtkToggleButton *togglebutton,
gpointer user_data)
{
}
void
on_forcefeedback_toggled (GtkToggleButton *togglebutton,
gpointer user_data)
{
}
void
on_checkbutton_reverserx_toggled (GtkToggleButton *togglebutton,
gpointer user_data)
{
}
void
on_checkbutton_reversery_toggled (GtkToggleButton *togglebutton,
gpointer user_data)
{
}
void
on_checkbutton_reversely_toggled (GtkToggleButton *togglebutton,
gpointer user_data)
{
}
void
on_Clear (GtkButton *button,
gpointer user_data)
{
}
void
on_Remove (GtkButton *button,
gpointer user_data)
{
}
void
OnConf_Ok (GtkButton *button,
gpointer user_data)
{
}
void
OnConf_Cancel (GtkButton *button,
gpointer user_data)
{
}

68
plugins/onepad/Linux/callbacks.h
View File

@ -1,68 +0,0 @@
#include <gtk/gtk.h>
#define VERSION "0.1"
void
OnAbout_Ok (GtkDialog *dialog,
gint response_id,
gpointer user_data);
void
OnConf_Pad1 (GtkButton *button,
gpointer user_data);
void
OnConf_Pad2 (GtkButton *button,
gpointer user_data);
void
OnConf_Pad3 (GtkButton *button,
gpointer user_data);
void
OnConf_Pad4 (GtkButton *button,
gpointer user_data);
void
on_joydevicescombo_changed (GtkComboBox *combobox,
gpointer user_data);
void
OnConf_Key (GtkButton *button,
gpointer user_data);
void
on_checkbutton_reverselx_toggled (GtkToggleButton *togglebutton,
gpointer user_data);
void
on_forcefeedback_toggled (GtkToggleButton *togglebutton,
gpointer user_data);
void
on_checkbutton_reverserx_toggled (GtkToggleButton *togglebutton,
gpointer user_data);
void
on_checkbutton_reversery_toggled (GtkToggleButton *togglebutton,
gpointer user_data);
void
on_checkbutton_reversely_toggled (GtkToggleButton *togglebutton,
gpointer user_data);
void
on_Clear (GtkButton *button,
gpointer user_data);
void
on_Remove (GtkButton *button,
gpointer user_data);
void
OnConf_Ok (GtkButton *button,
gpointer user_data);
void
OnConf_Cancel (GtkButton *button,
gpointer user_data);

232
plugins/onepad/Linux/dialog.cpp
View File

@ -23,13 +23,26 @@
#include <gdk/gdkx.h>
extern string KeyName(int pad, int key);
extern const char* s_pGuiKeyMap[];
int current_pad = 0;
GtkWidget *rev_lx_check, *rev_ly_check, *force_feedback_check, *rev_rx_check, *rev_ry_check;
const char* s_pGuiKeyMap[] =
{
"L2", "R2", "L1", "R1",
"Triangle", "Circle", "Cross", "Square",
"Select", "L3", "R3", "Start",
"Up", "Right", "Down", "Left",
"Lx", "Rx", "Ly", "Ry",
"L_Up", "L_Right", "L_Down", "L_Left",
"R_Up", "R_Right", "R_Down", "R_Left"
};
enum
{
COL_PAD = 0,
COL_BUTTON,
COL_KEY,
COL_PAD_NUM,
COL_VALUE,
NUM_COLS
};
@ -39,10 +52,10 @@ class keys_tree
private:
GtkTreeStore *treestore;
GtkTreeModel *model;
GtkTreeView *view;
bool has_columns;
public:
GtkWidget *keys_tree_view;
void populate_tree_view()
void populate()
{
GtkTreeIter toplevel;
@ -54,11 +67,21 @@ class keys_tree
{
if (get_key(pad, key) != 0)
{
string pad_value;
switch(pad)
{
case 0: pad_value = "Pad 1"; break;
case 2: pad_value = "Pad 1"; break;
case 1: pad_value = "Pad 2"; break;
case 3: pad_value = "Pad 2"; break;
default: pad_value = "Invalid"; break;
}
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel,
COL_PAD, pad,
COL_PAD, pad_value.c_str(),
COL_BUTTON, s_pGuiKeyMap[key],
COL_KEY, KeyName(pad, key).c_str(),
COL_PAD_NUM, pad,
COL_VALUE, key,
-1);
}
@ -66,7 +89,7 @@ class keys_tree
}
}
void create_a_column(GtkWidget *view, const char *name, int num, bool visible)
void create_a_column(const char *name, int num, bool visible)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
@ -75,7 +98,7 @@ class keys_tree
gtk_tree_view_column_set_title(col, name);
/* pack tree view column into tree view */
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_append_column(view, col);
renderer = gtk_cell_renderer_text_new();
@ -92,32 +115,45 @@ class keys_tree
{
if (!has_columns)
{
create_a_column(view, "Pad #", COL_PAD, true);
create_a_column(view, "Pad Button", COL_BUTTON, true);
create_a_column(view, "Key Value", COL_KEY, true);
create_a_column(view, "Internal", COL_VALUE, false);
create_a_column("Pad #", COL_PAD, true);
create_a_column("Pad Button", COL_BUTTON, true);
create_a_column("Key Value", COL_KEY, true);
create_a_column("Pad Num", COL_PAD_NUM, false);
create_a_column("Internal", COL_VALUE, false);
has_columns = true;
}
}
void init_tree_view()
public:
GtkWidget *view_widget()
{
return GTK_WIDGET(view);
}
void new_tree()
{
view = GTK_TREE_VIEW(gtk_tree_view_new());
}
void init()
{
treestore = gtk_tree_store_new(NUM_COLS,
G_TYPE_UINT,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_UINT);
G_TYPE_STRING,
G_TYPE_UINT,
G_TYPE_UINT);
populate_tree_view();
create_columns(keys_tree_view);
populate();
create_columns(GTK_WIDGET(view));
model = GTK_TREE_MODEL(treestore);
gtk_tree_view_set_model(GTK_TREE_VIEW(keys_tree_view), model);
gtk_tree_view_set_model(view, model);
g_object_unref(model); /* destroy model automatically with view */
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(keys_tree_view)),
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(view),
GTK_SELECTION_SINGLE);
}
@ -125,7 +161,7 @@ class keys_tree
void clear_all()
{
clearPAD();
init_tree_view();
init();
}
void remove_selected()
@ -133,15 +169,15 @@ class keys_tree
GtkTreeSelection *selection;
GtkTreeIter iter;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(keys_tree_view));
selection = gtk_tree_view_get_selection(view);
if (gtk_tree_selection_get_selected(selection, &model, &iter))
{
int pad;
int key;
gtk_tree_model_get(model, &iter, COL_PAD, &pad, COL_VALUE, &key,-1);
gtk_tree_model_get(model, &iter, COL_PAD_NUM, &pad, COL_VALUE, &key,-1);
set_key(pad, key, 0);
init_tree_view();
init();
}
else
{
@ -189,7 +225,7 @@ typedef struct
{
GtkWidget *widget;
int index;
void put(char* lbl, int i, GtkFixed *fix, int x, int y)
void put(const char* lbl, int i, GtkFixed *fix, int x, int y)
{
widget = gtk_button_new_with_label(lbl);
gtk_fixed_put(fix, widget, x, y);
@ -208,8 +244,8 @@ void on_conf_key(GtkButton *button, gpointer user_data)
if (id == -1) return;
int pad = id / MAX_KEYS;
int key = id % MAX_KEYS;
int pad = current_pad; //id / MAX_KEYS;
int key = id; // % MAX_KEYS;
// save the joystick states
UpdateJoysticks();
@ -281,7 +317,7 @@ void on_conf_key(GtkButton *button, gpointer user_data)
}
}
fir->init_tree_view();
fir->init();
}
void on_remove_clicked(GtkButton *button, gpointer user_data)
@ -294,6 +330,91 @@ void on_clear_clicked(GtkButton *button, gpointer user_data)
fir->clear_all();
}
void joy_changed(GtkComboBox *box, gpointer user_data)
{
int joyid = gtk_combo_box_get_active(box);
// unassign every joystick with this pad
for (int i = 0; i < (int)s_vjoysticks.size(); ++i)
{
if (s_vjoysticks[i]->GetPAD() == s_selectedpad) s_vjoysticks[i]->Assign(-1);
}
if (joyid >= 0 && joyid < (int)s_vjoysticks.size()) s_vjoysticks[joyid]->Assign(current_pad);
}
void pad_changed(GtkComboBox *box, gpointer user_data)
{
int temp = gtk_combo_box_get_active(box);
if (temp != -1) current_pad = temp;
fir->init();
int options = (conf.options >> (16 * current_pad));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rev_lx_check), (options & PADOPTION_REVERTLX));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rev_ly_check), (options & PADOPTION_REVERTLY));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rev_rx_check), (options & PADOPTION_REVERTRX));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rev_ry_check), (options & PADOPTION_REVERTRY));
}
void on_rev_lx(GtkComboBox *box, gpointer user_data)
{
int mask = (PADOPTION_REVERTLX << (16 * current_pad));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rev_lx_check)))
conf.options |= mask;
else
conf.options &= ~mask;
}
void on_rev_ly(GtkComboBox *box, gpointer user_data)
{
int mask = (PADOPTION_REVERTLY << (16 * current_pad));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rev_ly_check)))
conf.options |= mask;
else
conf.options &= ~mask;
}
void on_rev_rx(GtkComboBox *box, gpointer user_data)
{
int mask = (PADOPTION_REVERTRX << (16 * current_pad));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rev_rx_check)))
conf.options |= mask;
else
conf.options &= ~mask;
}
void on_rev_ry(GtkComboBox *box, gpointer user_data)
{
int mask = (PADOPTION_REVERTRY << (16 * current_pad));
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(rev_ry_check)))
conf.options |= mask;
else
conf.options &= ~mask;
}
//void on_forcefeedback_toggled(GtkToggleButton *togglebutton, gpointer user_data)
//{
// int mask = PADOPTION_REVERTLX << (16 * s_selectedpad);
//
// if (gtk_toggle_button_get_active(togglebutton))
// {
// conf.options |= mask;
//
// int joyid = gtk_combo_box_get_active(GTK_COMBO_BOX(s_devicecombo));
//
// if (joyid >= 0 && joyid < (int)s_vjoysticks.size()) s_vjoysticks[joyid]->TestForce();
// }
// else
// {
// conf.options &= ~mask;
// }
//}
void DisplayDialog()
{
int return_value;
@ -316,7 +437,7 @@ void DisplayDialog()
GtkWidget *keys_static_frame, *keys_static_box;
GtkWidget *keys_static_area;
dialog_buttons btn[29];
GtkWidget *rev_lx_check, *rev_ly_check, *force_feedback_check, *rev_rx_check, *rev_ry_check;
fir = new keys_tree;
/* Create the widgets */
@ -336,17 +457,23 @@ void DisplayDialog()
gtk_combo_box_append_text(GTK_COMBO_BOX(pad_choose_cbox), "Pad 1 (alt)");
gtk_combo_box_append_text(GTK_COMBO_BOX(pad_choose_cbox), "Pad 2 (alt)");
gtk_combo_box_set_active(GTK_COMBO_BOX(pad_choose_cbox), 0);
current_pad = 0;
g_signal_connect(GTK_OBJECT (pad_choose_cbox), "changed", G_CALLBACK(pad_changed), NULL);
joy_choose_cbox = gtk_combo_box_new_text ();
populate_new_joysticks(GTK_COMBO_BOX(joy_choose_cbox));
gtk_combo_box_set_active(GTK_COMBO_BOX(joy_choose_cbox), Get_Current_Joystick());
fir->keys_tree_view = gtk_tree_view_new();
g_signal_connect(GTK_OBJECT (joy_choose_cbox), "changed", G_CALLBACK(joy_changed), NULL);
fir->new_tree();
keys_tree_clear_btn = gtk_button_new_with_label("Clear All");
g_signal_connect(GTK_OBJECT (keys_tree_clear_btn), "clicked", G_CALLBACK(on_clear_clicked), NULL);
gtk_widget_set_size_request(keys_tree_clear_btn, 64, 24);
keys_tree_remove_btn = gtk_button_new_with_label("Remove");
g_signal_connect(GTK_OBJECT (keys_tree_remove_btn), "clicked", G_CALLBACK(on_remove_clicked), NULL);
gtk_widget_set_size_request(keys_tree_remove_btn, 64, 24);
main_box = gtk_vbox_new(false, 5);
main_frame = gtk_frame_new ("Onepad Config");
gtk_container_add (GTK_CONTAINER(main_frame), main_box);
@ -414,11 +541,32 @@ void DisplayDialog()
btn[26].put("Down", 26, GTK_FIXED(keys_static_area), static_offset + 392, 312);
btn[27].put("Left", 27, GTK_FIXED(keys_static_area), static_offset + 328, 272);
int options = (conf.options >> (16 * current_pad));
rev_lx_check = gtk_check_button_new_with_label("Reverse Lx");
gtk_fixed_put(GTK_FIXED(keys_static_area), rev_lx_check, static_offset + 40, 344);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rev_lx_check), (options & PADOPTION_REVERTLX));
g_signal_connect(GTK_OBJECT (rev_lx_check), "toggled", G_CALLBACK(on_rev_lx), NULL);
rev_ly_check = gtk_check_button_new_with_label("Reverse Ly");
gtk_fixed_put(GTK_FIXED(keys_static_area), rev_ly_check, static_offset + 40, 368);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rev_ly_check), (options & PADOPTION_REVERTLY));
g_signal_connect(GTK_OBJECT (rev_ly_check), "toggled", G_CALLBACK(on_rev_ly), NULL);
rev_rx_check = gtk_check_button_new_with_label("Reverse Rx");
gtk_fixed_put(GTK_FIXED(keys_static_area), rev_rx_check, static_offset + 368, 344);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rev_rx_check), (options & PADOPTION_REVERTRX));
g_signal_connect(GTK_OBJECT (rev_rx_check), "toggled", G_CALLBACK(on_rev_rx), NULL);
rev_ry_check = gtk_check_button_new_with_label("Reverse Ry");
gtk_fixed_put(GTK_FIXED(keys_static_area), rev_ry_check, static_offset + 368, 368);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(rev_ry_check), (options & PADOPTION_REVERTRY));
g_signal_connect(GTK_OBJECT (rev_ry_check), "toggled", G_CALLBACK(on_rev_ry), NULL);
keys_box = gtk_hbox_new(false, 5);
keys_frame = gtk_frame_new ("Key Settings");
gtk_container_add (GTK_CONTAINER(keys_frame), keys_box);
gtk_box_pack_start (GTK_BOX (keys_tree_box), fir->keys_tree_view, true, true, 0);
gtk_box_pack_start (GTK_BOX (keys_tree_box), fir->view_widget(), true, true, 0);
gtk_box_pack_end (GTK_BOX (keys_btn_box), keys_tree_clear_btn, false, false, 0);
gtk_box_pack_end (GTK_BOX (keys_btn_box), keys_tree_remove_btn, false, false, 0);
@ -434,7 +582,7 @@ void DisplayDialog()
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), main_frame);
fir->init_tree_view();
fir->init();
gtk_widget_show_all (dialog);
@ -443,24 +591,6 @@ void DisplayDialog()
if (return_value == GTK_RESPONSE_ACCEPT)
{
SaveConfig();
// DebugEnabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(debug_check));
// if (gtk_combo_box_get_active(GTK_COMBO_BOX(int_box)) != -1)
// Interpolation = gtk_combo_box_get_active(GTK_COMBO_BOX(int_box));
//
// EffectsDisabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(effects_check));
//
// if (gtk_combo_box_get_active(GTK_COMBO_BOX(reverb_box)) != -1)
// ReverbBoost = gtk_combo_box_get_active(GTK_COMBO_BOX(reverb_box));
//
// if (gtk_combo_box_get_active(GTK_COMBO_BOX(mod_box)) != 1)
// OutputModule = 0;
// else
// OutputModule = FindOutputModuleById( PortaudioOut->GetIdent() );
//
// SndOutLatencyMS = gtk_range_get_value(GTK_RANGE(latency_slide));
//
// if (gtk_combo_box_get_active(GTK_COMBO_BOX(sync_box)) != -1)
// SynchMode = gtk_combo_box_get_active(GTK_COMBO_BOX(sync_box));
}
LoadConfig();

371
plugins/onepad/Linux/gui.cpp
View File

@ -1,371 +0,0 @@
/* OnePAD - author: arcum42(@gmail.com)
* Copyright (C) 2009
*
* Based on ZeroPAD, author zerofrog@gmail.com
* Copyright (C) 2006-2007
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <string.h>
#include <gtk/gtk.h>
#include <pthread.h>
#include "joystick.h"
#include "onepad.h"
#include "linux.h"
extern "C"
{
#include "interface.h"
#include "support.h"
#include "callbacks.h"
}
GtkWidget *Conf, *About, *MsgDlg;
GtkWidget *s_devicecombo;
GtkTreeStore *treestore;
GtkTreeModel *model;
bool has_columns = false;
extern string KeyName(int pad, int key);
extern const char* s_pGuiKeyMap[];
extern void UpdateConf(int pad);
enum
{
COL_PAD = 0,
COL_BUTTON,
COL_KEY,
COL_VALUE,
NUM_COLS
};
void populate_tree_view()
{
GtkTreeIter toplevel;
gtk_tree_store_clear(treestore);
for (int pad = 0; pad < 2 * MAX_SUB_KEYS; pad++)
{
for (int key = 0; key < MAX_KEYS; key++)
{
if (get_key(pad, key) != 0)
{
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel,
COL_PAD, pad,
COL_BUTTON, s_pGuiKeyMap[key],
COL_KEY, KeyName(pad, key).c_str(),
COL_VALUE, key,
-1);
}
}
}
}
void create_a_column(GtkWidget *view, const char *name, int num, bool visible)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, name);
/* pack tree view column into tree view */
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
renderer = gtk_cell_renderer_text_new();
/* pack cell renderer into tree view column */
gtk_tree_view_column_pack_start(col, renderer, TRUE);
/* connect 'text' property of the cell renderer to
* model column that contains the first name */
gtk_tree_view_column_add_attribute(col, renderer, "text", num);
gtk_tree_view_column_set_visible(col, visible);
}
void create_columns(GtkWidget *view)
{
if (!has_columns)
{
create_a_column(view, "Pad #", COL_PAD, true);
create_a_column(view, "Pad Button", COL_BUTTON, true);
create_a_column(view, "Key Value", COL_KEY, true);
create_a_column(view, "Internal", COL_VALUE, false);
has_columns = true;
}
}
void init_tree_view()
{
GtkWidget *view;
view = lookup_widget(Conf,"padtreeview");
treestore = gtk_tree_store_new(NUM_COLS,
G_TYPE_UINT,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_UINT);
populate_tree_view();
create_columns(view);
model = GTK_TREE_MODEL(treestore);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
g_object_unref(model); /* destroy model automatically with view */
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
GTK_SELECTION_SINGLE);
}
void destroy_tree_view()
{
has_columns = false;
//g_object_unref(treestore);
}
/*void add_tree_row(int pad, int key)
{
GtkTreeIter toplevel;
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel,
COL_PAD, pad,
COL_BUTTON, s_pGuiKeyMap[key],
COL_KEY, KeyName(pad, key).c_str(),
COL_VALUE, key,
-1);
}
void delete_tree_row()
{
}*/
void OnMsg_Ok()
{
gtk_widget_destroy(MsgDlg);
gtk_main_quit();
}
// GUI event handlers
void on_joydevicescombo_changed(GtkComboBox *combobox, gpointer user_data)
{
int joyid = gtk_combo_box_get_active(combobox);
// unassign every joystick with this pad
for (int i = 0; i < (int)s_vjoysticks.size(); ++i)
{
if (s_vjoysticks[i]->GetPAD() == s_selectedpad) s_vjoysticks[i]->Assign(-1);
}
if (joyid >= 0 && joyid < (int)s_vjoysticks.size()) s_vjoysticks[joyid]->Assign(s_selectedpad);
}
void on_checkbutton_reverselx_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
int mask = PADOPTION_REVERTLX << (16 * s_selectedpad);
if (gtk_toggle_button_get_active(togglebutton))
conf.options |= mask;
else
conf.options &= ~mask;
}
void on_checkbutton_reversely_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
int mask = PADOPTION_REVERTLY << (16 * s_selectedpad);
if (gtk_toggle_button_get_active(togglebutton))
conf.options |= mask;
else
conf.options &= ~mask;
}
void on_checkbutton_reverserx_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
int mask = PADOPTION_REVERTRX << (16 * s_selectedpad);
if (gtk_toggle_button_get_active(togglebutton))
conf.options |= mask;
else
conf.options &= ~mask;
}
void on_checkbutton_reversery_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
int mask = PADOPTION_REVERTRY << (16 * s_selectedpad);
if (gtk_toggle_button_get_active(togglebutton))
conf.options |= mask;
else
conf.options &= ~mask;
}
void on_forcefeedback_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
int mask = PADOPTION_REVERTLX << (16 * s_selectedpad);
if (gtk_toggle_button_get_active(togglebutton))
{
conf.options |= mask;
int joyid = gtk_combo_box_get_active(GTK_COMBO_BOX(s_devicecombo));
if (joyid >= 0 && joyid < (int)s_vjoysticks.size()) s_vjoysticks[joyid]->TestForce();
}
else
{
conf.options &= ~mask;
}
}
void SysMessage(char *fmt, ...)
{
GtkWidget *Ok, *Txt;
GtkWidget *Box, *Box1;
va_list list;
char msg[512];
va_start(list, fmt);
vsprintf(msg, fmt, list);
va_end(list);
if (msg[strlen(msg)-1] == '\n') msg[strlen(msg)-1] = 0;
MsgDlg = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(MsgDlg), GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(MsgDlg), "ZeroPad");
gtk_container_set_border_width(GTK_CONTAINER(MsgDlg), 5);
Box = gtk_vbox_new(5, 0);
gtk_container_add(GTK_CONTAINER(MsgDlg), Box);
gtk_widget_show(Box);
Txt = gtk_label_new(msg);
gtk_box_pack_start(GTK_BOX(Box), Txt, FALSE, FALSE, 5);
gtk_widget_show(Txt);
Box1 = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(Box), Box1, FALSE, FALSE, 0);
gtk_widget_show(Box1);
Ok = gtk_button_new_with_label("Ok");
gtk_signal_connect(GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(OnMsg_Ok), NULL);
gtk_container_add(GTK_CONTAINER(Box1), Ok);
GTK_WIDGET_SET_FLAGS(Ok, GTK_CAN_DEFAULT);
gtk_widget_show(Ok);
gtk_widget_show(MsgDlg);
gtk_main();
}
void on_Clear(GtkButton *button, gpointer user_data)
{
clearPAD();
init_tree_view();
}
void on_Remove(GtkButton *button, gpointer user_data)
{
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkWidget *view;
view = lookup_widget(Conf,"padtreeview");
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if (gtk_tree_selection_get_selected(selection, &model, &iter))
{
int pad;
int key;
gtk_tree_model_get(model, &iter, COL_PAD, &pad, COL_VALUE, &key,-1);
set_key(pad, key, 0);
init_tree_view();
}
else
{
// Not selected.
}
}
void OnConf_Pad1(GtkButton *button, gpointer user_data)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) UpdateConf(0);
}
void OnConf_Pad2(GtkButton *button, gpointer user_data)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) UpdateConf(1);
}
void OnConf_Pad3(GtkButton *button, gpointer user_data)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) UpdateConf(2);
}
void OnConf_Pad4(GtkButton *button, gpointer user_data)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button))) UpdateConf(3);
}
void OnConf_Ok(GtkButton *button, gpointer user_data)
{
// conf.analog = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Analog));
SaveConfig();
destroy_tree_view();
gtk_widget_destroy(Conf);
gtk_main_quit();
}
void OnConf_Cancel(GtkButton *button, gpointer user_data)
{
gtk_widget_destroy(Conf);
gtk_main_quit();
LoadConfig(); // load previous config
}
void OnAbout_Ok(GtkDialog *About, gint response_id, gpointer user_data)
{
gtk_widget_destroy(GTK_WIDGET(About));
gtk_main_quit();
}
EXPORT_C_(void) PADabout()
{
About = create_About();
gtk_widget_show_all(About);
gtk_main();
}
EXPORT_C_(s32) PADtest()
{
return 0;
}

721
plugins/onepad/Linux/interface.c
View File

@ -1,721 +0,0 @@
/*
* DO NOT EDIT THIS FILE - it is generated by Glade.
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include "callbacks.h"
#include "interface.h"
#include "support.h"
#define GLADE_HOOKUP_OBJECT(component,widget,name) \
g_object_set_data_full (G_OBJECT (component), name, \
gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref)
#define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \
g_object_set_data (G_OBJECT (component), name, widget)
GtkWidget*
create_About (void)
{
GtkWidget *About;
const gchar *authors[] = {
"Author: arcum42(@gmail.com)",
"Forked from ZeroPad, by:",
"zerofrog(@gmail.com)",
"Thanks to:",
" linuzappz <linuzappz@hotmail.com>",
"florin sasu <florinsasu@hotmail.com>",
"and SSSPSXPad, TwinPad authors",
NULL
};
/* TRANSLATORS: Replace this string with your names, one name per line. */
gchar *translators = _("translator-credits");
About = gtk_about_dialog_new ();
gtk_widget_set_name (About, "About");
gtk_container_set_border_width (GTK_CONTAINER (About), 5);
gtk_window_set_destroy_with_parent (GTK_WINDOW (About), TRUE);
gtk_about_dialog_set_version (GTK_ABOUT_DIALOG (About), VERSION);
gtk_about_dialog_set_name (GTK_ABOUT_DIALOG (About), _("OnePAD"));
gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG (About), authors);
gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (About), translators);
g_signal_connect ((gpointer) About, "response",
G_CALLBACK (OnAbout_Ok),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (About, About, "About");
return About;
}
GtkWidget*
create_Conf (void)
{
GtkWidget *Conf;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *frame1;
GtkWidget *alignment1;
GtkWidget *hbox1;
GtkWidget *PAD1;
GSList *PAD1_group = NULL;
GtkWidget *PAD2;
GtkWidget *PAD3;
GtkWidget *PAD4;
GtkWidget *label2;
GtkWidget *vbox2;
GtkWidget *label5;
GtkWidget *joydevicescombo;
GtkWidget *fixed1;
GtkWidget *vbox3;
GtkWidget *hbox3;
GtkWidget *fixed2;
GtkWidget *fixed3;
GtkWidget *Left;
GtkWidget *Up;
GtkWidget *Right;
GtkWidget *Down;
GtkWidget *L2;
GtkWidget *L1;
GtkWidget *Select;
GtkWidget *Start;
GtkWidget *L3;
GtkWidget *R3;
GtkWidget *Analog;
GtkWidget *Square;
GtkWidget *Triangle;
GtkWidget *Circle;
GtkWidget *Cross;
GtkWidget *R2;
GtkWidget *R1;
GtkWidget *label3;
GtkWidget *label6;
GtkWidget *L_Left;
GtkWidget *Lx;
GtkWidget *Ly;
GtkWidget *L_Down;
GtkWidget *L_Right;
GtkWidget *checkbutton_reverselx;
GtkWidget *R_Up;
GtkWidget *R_Left;
GtkWidget *Rx;
GtkWidget *Ry;
GtkWidget *R_Right;
GtkWidget *R_Down;
GtkWidget *forcefeedback;
GtkWidget *checkbutton_reverserx;
GtkWidget *checkbutton_reversery;
GtkWidget *frame2;
GtkWidget *alignment2;
GtkWidget *scrolledwindow2;
GtkWidget *padtreeview;
GtkWidget *label7;
GtkWidget *checkbutton_reversely;
GtkWidget *L_Up;
GtkWidget *clear_button;
GtkWidget *remove_button;
GtkWidget *dialog_action_area1;
GtkWidget *okbutton1;
GtkWidget *cancelbutton1;
Conf = gtk_dialog_new ();
gtk_widget_set_name (Conf, "Conf");
gtk_window_set_title (GTK_WINDOW (Conf), _("OnePAD Configuration Dialog"));
gtk_window_set_type_hint (GTK_WINDOW (Conf), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (Conf)->vbox;
gtk_widget_set_name (dialog_vbox1, "dialog_vbox1");
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox1, "vbox1");
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_set_name (frame1, "frame1");
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox1), frame1, FALSE, FALSE, 0);
alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment1, "alignment1");
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (frame1), alignment1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 0, 0, 12, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox1, "hbox1");
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (alignment1), hbox1);
PAD1 = gtk_radio_button_new_with_mnemonic (NULL, _("PAD1"));
gtk_widget_set_name (PAD1, "PAD1");
gtk_widget_show (PAD1);
gtk_box_pack_start (GTK_BOX (hbox1), PAD1, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (PAD1), PAD1_group);
PAD1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (PAD1));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (PAD1), TRUE);
PAD2 = gtk_radio_button_new_with_mnemonic (NULL, _("PAD2"));
gtk_widget_set_name (PAD2, "PAD2");
gtk_widget_show (PAD2);
gtk_box_pack_start (GTK_BOX (hbox1), PAD2, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (PAD2), PAD1_group);
PAD1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (PAD2));
PAD3 = gtk_radio_button_new_with_mnemonic (NULL, _("PAD1 alt."));
gtk_widget_set_name (PAD3, "PAD3");
gtk_widget_show (PAD3);
gtk_box_pack_start (GTK_BOX (hbox1), PAD3, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (PAD3), PAD1_group);
PAD1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (PAD3));
PAD4 = gtk_radio_button_new_with_mnemonic (NULL, _("PAD2 alt."));
gtk_widget_set_name (PAD4, "PAD4");
gtk_widget_show (PAD4);
gtk_box_pack_start (GTK_BOX (hbox1), PAD4, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (PAD4), PAD1_group);
PAD1_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (PAD4));
label2 = gtk_label_new (_("<b>Choose PAD to modify</b>"));
gtk_widget_set_name (label2, "label2");
gtk_widget_show (label2);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label2);
gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox2, "vbox2");
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, FALSE, TRUE, 0);
label5 = gtk_label_new (_("Joystick to use for this PAD"));
gtk_widget_set_name (label5, "label5");
gtk_widget_show (label5);
gtk_box_pack_start (GTK_BOX (vbox2), label5, FALSE, FALSE, 0);
joydevicescombo = gtk_combo_box_entry_new_text ();
gtk_widget_set_name (joydevicescombo, "joydevicescombo");
gtk_widget_show (joydevicescombo);
gtk_box_pack_start (GTK_BOX (vbox2), joydevicescombo, FALSE, TRUE, 0);
fixed1 = gtk_fixed_new ();
gtk_widget_set_name (fixed1, "fixed1");
gtk_widget_show (fixed1);
gtk_box_pack_start (GTK_BOX (vbox1), fixed1, TRUE, TRUE, 0);
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox3, "vbox3");
gtk_widget_show (vbox3);
gtk_fixed_put (GTK_FIXED (fixed1), vbox3, 0, 0);
gtk_widget_set_size_request (vbox3, 0, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox3, "hbox3");
gtk_widget_show (hbox3);
gtk_box_pack_start (GTK_BOX (vbox3), hbox3, FALSE, FALSE, 0);
fixed2 = gtk_fixed_new ();
gtk_widget_set_name (fixed2, "fixed2");
gtk_widget_show (fixed2);
gtk_box_pack_start (GTK_BOX (hbox3), fixed2, FALSE, FALSE, 0);
fixed3 = gtk_fixed_new ();
gtk_widget_set_name (fixed3, "fixed3");
gtk_widget_show (fixed3);
gtk_box_pack_start (GTK_BOX (hbox3), fixed3, FALSE, FALSE, 0);
Left = gtk_button_new_with_mnemonic (_("Left"));
gtk_widget_set_name (Left, "Left");
gtk_widget_show (Left);
gtk_fixed_put (GTK_FIXED (fixed1), Left, 320, 104);
gtk_widget_set_size_request (Left, 64, 24);
Up = gtk_button_new_with_mnemonic (_("Up"));
gtk_widget_set_name (Up, "Up");
gtk_widget_show (Up);
gtk_fixed_put (GTK_FIXED (fixed1), Up, 384, 80);
gtk_widget_set_size_request (Up, 64, 24);
Right = gtk_button_new_with_mnemonic (_("Right"));
gtk_widget_set_name (Right, "Right");
gtk_widget_show (Right);
gtk_fixed_put (GTK_FIXED (fixed1), Right, 448, 104);
gtk_widget_set_size_request (Right, 64, 24);
Down = gtk_button_new_with_mnemonic (_("Down"));
gtk_widget_set_name (Down, "Down");
gtk_widget_show (Down);
gtk_fixed_put (GTK_FIXED (fixed1), Down, 384, 128);
gtk_widget_set_size_request (Down, 64, 24);
L2 = gtk_button_new_with_mnemonic (_("L2"));
gtk_widget_set_name (L2, "L2");
gtk_widget_show (L2);
gtk_fixed_put (GTK_FIXED (fixed1), L2, 384, 8);
gtk_widget_set_size_request (L2, 64, 24);
L1 = gtk_button_new_with_mnemonic (_("L1"));
gtk_widget_set_name (L1, "L1");
gtk_widget_show (L1);
gtk_fixed_put (GTK_FIXED (fixed1), L1, 384, 32);
gtk_widget_set_size_request (L1, 64, 24);
Select = gtk_button_new_with_mnemonic (_("Select"));
gtk_widget_set_name (Select, "Select");
gtk_widget_show (Select);
gtk_fixed_put (GTK_FIXED (fixed1), Select, 520, 48);
gtk_widget_set_size_request (Select, 64, 24);
Start = gtk_button_new_with_mnemonic (_("Start"));
gtk_widget_set_name (Start, "Start");
gtk_widget_show (Start);
gtk_fixed_put (GTK_FIXED (fixed1), Start, 592, 48);
gtk_widget_set_size_request (Start, 64, 24);
L3 = gtk_button_new_with_mnemonic (_("L3"));
gtk_widget_set_name (L3, "L3");
gtk_widget_show (L3);
gtk_fixed_put (GTK_FIXED (fixed1), L3, 520, 8);
gtk_widget_set_size_request (L3, 64, 24);
R3 = gtk_button_new_with_mnemonic (_("R3"));
gtk_widget_set_name (R3, "R3");
gtk_widget_show (R3);
gtk_fixed_put (GTK_FIXED (fixed1), R3, 592, 8);
gtk_widget_set_size_request (R3, 64, 24);
Analog = gtk_button_new_with_mnemonic (_("Analog"));
gtk_widget_set_name (Analog, "Analog");
gtk_widget_show (Analog);
gtk_fixed_put (GTK_FIXED (fixed1), Analog, 552, 104);
gtk_widget_set_size_request (Analog, 64, 24);
Square = gtk_button_new_with_mnemonic (_("Square"));
gtk_widget_set_name (Square, "Square");
gtk_widget_show (Square);
gtk_fixed_put (GTK_FIXED (fixed1), Square, 648, 104);
gtk_widget_set_size_request (Square, 64, 24);
Triangle = gtk_button_new_with_mnemonic (_("Triangle"));
gtk_widget_set_name (Triangle, "Triangle");
gtk_widget_show (Triangle);
gtk_fixed_put (GTK_FIXED (fixed1), Triangle, 712, 80);
gtk_widget_set_size_request (Triangle, 64, 24);
Circle = gtk_button_new_with_mnemonic (_("Circle"));
gtk_widget_set_name (Circle, "Circle");
gtk_widget_show (Circle);
gtk_fixed_put (GTK_FIXED (fixed1), Circle, 776, 104);
gtk_widget_set_size_request (Circle, 64, 24);
Cross = gtk_button_new_with_mnemonic (_("Cross"));
gtk_widget_set_name (Cross, "Cross");
gtk_widget_show (Cross);
gtk_fixed_put (GTK_FIXED (fixed1), Cross, 712, 128);
gtk_widget_set_size_request (Cross, 64, 24);
R2 = gtk_button_new_with_mnemonic (_("R2"));
gtk_widget_set_name (R2, "R2");
gtk_widget_show (R2);
gtk_fixed_put (GTK_FIXED (fixed1), R2, 712, 8);
gtk_widget_set_size_request (R2, 64, 24);
R1 = gtk_button_new_with_mnemonic (_("R1"));
gtk_widget_set_name (R1, "R1");
gtk_widget_show (R1);
gtk_fixed_put (GTK_FIXED (fixed1), R1, 712, 32);
gtk_widget_set_size_request (R1, 64, 24);
label3 = gtk_label_new (_("Analog Controls (move mouse or analog joystick to select)"));
gtk_widget_set_name (label3, "label3");
gtk_widget_show (label3);
gtk_fixed_put (GTK_FIXED (fixed1), label3, 384, 168);
gtk_widget_set_size_request (label3, 400, 24);
gtk_label_set_line_wrap (GTK_LABEL (label3), TRUE);
gtk_label_set_single_line_mode (GTK_LABEL (label3), TRUE);
label6 = gtk_label_new (_("(Note: The analog key controls and joystick controls do not work well together currently, and should not be mixed. )"));
gtk_widget_set_name (label6, "label6");
gtk_widget_show (label6);
gtk_fixed_put (GTK_FIXED (fixed1), label6, 352, 192);
gtk_widget_set_size_request (label6, 448, 40);
gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_CENTER);
gtk_label_set_line_wrap (GTK_LABEL (label6), TRUE);
L_Left = gtk_button_new_with_mnemonic (_("Left"));
gtk_widget_set_name (L_Left, "L_Left");
gtk_widget_show (L_Left);
gtk_fixed_put (GTK_FIXED (fixed1), L_Left, 320, 272);
gtk_widget_set_size_request (L_Left, 64, 24);
Lx = gtk_button_new_with_mnemonic (_("Lx"));
gtk_widget_set_name (Lx, "Lx");
gtk_widget_show (Lx);
gtk_fixed_put (GTK_FIXED (fixed1), Lx, 384, 264);
gtk_widget_set_size_request (Lx, 64, 24);
Ly = gtk_button_new_with_mnemonic (_("Ly"));
gtk_widget_set_name (Ly, "Ly");
gtk_widget_show (Ly);
gtk_fixed_put (GTK_FIXED (fixed1), Ly, 384, 288);
gtk_widget_set_size_request (Ly, 64, 24);
L_Down = gtk_button_new_with_mnemonic (_("Down"));
gtk_widget_set_name (L_Down, "L_Down");
gtk_widget_show (L_Down);
gtk_fixed_put (GTK_FIXED (fixed1), L_Down, 384, 312);
gtk_widget_set_size_request (L_Down, 64, 24);
L_Right = gtk_button_new_with_mnemonic (_("Right"));
gtk_widget_set_name (L_Right, "L_Right");
gtk_widget_show (L_Right);
gtk_fixed_put (GTK_FIXED (fixed1), L_Right, 448, 272);
gtk_widget_set_size_request (L_Right, 64, 24);
checkbutton_reverselx = gtk_check_button_new_with_mnemonic (_("Reverse LX"));
gtk_widget_set_name (checkbutton_reverselx, "checkbutton_reverselx");
gtk_widget_show (checkbutton_reverselx);
gtk_fixed_put (GTK_FIXED (fixed1), checkbutton_reverselx, 360, 344);
gtk_widget_set_size_request (checkbutton_reverselx, 111, 22);
R_Up = gtk_button_new_with_mnemonic (_("Up"));
gtk_widget_set_name (R_Up, "R_Up");
gtk_widget_show (R_Up);
gtk_fixed_put (GTK_FIXED (fixed1), R_Up, 712, 240);
gtk_widget_set_size_request (R_Up, 64, 24);
R_Left = gtk_button_new_with_mnemonic (_("Left"));
gtk_widget_set_name (R_Left, "R_Left");
gtk_widget_show (R_Left);
gtk_fixed_put (GTK_FIXED (fixed1), R_Left, 648, 272);
gtk_widget_set_size_request (R_Left, 64, 24);
Rx = gtk_button_new_with_mnemonic (_("Rx"));
gtk_widget_set_name (Rx, "Rx");
gtk_widget_show (Rx);
gtk_fixed_put (GTK_FIXED (fixed1), Rx, 712, 264);
gtk_widget_set_size_request (Rx, 64, 24);
Ry = gtk_button_new_with_mnemonic (_("Ry"));
gtk_widget_set_name (Ry, "Ry");
gtk_widget_show (Ry);
gtk_fixed_put (GTK_FIXED (fixed1), Ry, 712, 288);
gtk_widget_set_size_request (Ry, 64, 24);
R_Right = gtk_button_new_with_mnemonic (_("Right"));
gtk_widget_set_name (R_Right, "R_Right");
gtk_widget_show (R_Right);
gtk_fixed_put (GTK_FIXED (fixed1), R_Right, 776, 272);
gtk_widget_set_size_request (R_Right, 64, 24);
R_Down = gtk_button_new_with_mnemonic (_("Down"));
gtk_widget_set_name (R_Down, "R_Down");
gtk_widget_show (R_Down);
gtk_fixed_put (GTK_FIXED (fixed1), R_Down, 712, 312);
gtk_widget_set_size_request (R_Down, 64, 24);
forcefeedback = gtk_check_button_new_with_mnemonic (_("Enable Force\nFeedback"));
gtk_widget_set_name (forcefeedback, "forcefeedback");
gtk_widget_show (forcefeedback);
gtk_fixed_put (GTK_FIXED (fixed1), forcefeedback, 528, 344);
gtk_widget_set_size_request (forcefeedback, 112, 48);
checkbutton_reverserx = gtk_check_button_new_with_mnemonic (_("Reverse RX"));
gtk_widget_set_name (checkbutton_reverserx, "checkbutton_reverserx");
gtk_widget_show (checkbutton_reverserx);
gtk_fixed_put (GTK_FIXED (fixed1), checkbutton_reverserx, 688, 344);
gtk_widget_set_size_request (checkbutton_reverserx, 111, 22);
checkbutton_reversery = gtk_check_button_new_with_mnemonic (_("Reverse RY"));
gtk_widget_set_name (checkbutton_reversery, "checkbutton_reversery");
gtk_widget_show (checkbutton_reversery);
gtk_fixed_put (GTK_FIXED (fixed1), checkbutton_reversery, 688, 368);
gtk_widget_set_size_request (checkbutton_reversery, 111, 22);
frame2 = gtk_frame_new (NULL);
gtk_widget_set_name (frame2, "frame2");
gtk_widget_show (frame2);
gtk_fixed_put (GTK_FIXED (fixed1), frame2, 0, 8);
gtk_widget_set_size_request (frame2, 312, 336);
alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_set_name (alignment2, "alignment2");
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (frame2), alignment2);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 0, 0, 12, 0);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_name (scrolledwindow2, "scrolledwindow2");
gtk_widget_show (scrolledwindow2);
gtk_container_add (GTK_CONTAINER (alignment2), scrolledwindow2);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN);
padtreeview = gtk_tree_view_new ();
gtk_widget_set_name (padtreeview, "padtreeview");
gtk_widget_show (padtreeview);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), padtreeview);
gtk_widget_set_extension_events (padtreeview, GDK_EXTENSION_EVENTS_ALL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (padtreeview), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (padtreeview), FALSE);
gtk_tree_view_set_hover_expand (GTK_TREE_VIEW (padtreeview), TRUE);
label7 = gtk_label_new (_("Key Settings"));
gtk_widget_set_name (label7, "label7");
gtk_widget_show (label7);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label7);
checkbutton_reversely = gtk_check_button_new_with_mnemonic (_("Reverse LY"));
gtk_widget_set_name (checkbutton_reversely, "checkbutton_reversely");
gtk_widget_show (checkbutton_reversely);
gtk_fixed_put (GTK_FIXED (fixed1), checkbutton_reversely, 360, 368);
gtk_widget_set_size_request (checkbutton_reversely, 111, 22);
L_Up = gtk_button_new_with_mnemonic (_("Up"));
gtk_widget_set_name (L_Up, "L_Up");
gtk_widget_show (L_Up);
gtk_fixed_put (GTK_FIXED (fixed1), L_Up, 384, 240);
gtk_widget_set_size_request (L_Up, 64, 24);
clear_button = gtk_button_new_with_mnemonic (_("Clear All"));
gtk_widget_set_name (clear_button, "clear_button");
gtk_widget_show (clear_button);
gtk_fixed_put (GTK_FIXED (fixed1), clear_button, 168, 352);
gtk_widget_set_size_request (clear_button, 70, 24);
remove_button = gtk_button_new_with_mnemonic (_("Remove"));
gtk_widget_set_name (remove_button, "remove_button");
gtk_widget_show (remove_button);
gtk_fixed_put (GTK_FIXED (fixed1), remove_button, 240, 352);
gtk_widget_set_size_request (remove_button, 70, 24);
dialog_action_area1 = GTK_DIALOG (Conf)->action_area;
gtk_widget_set_name (dialog_action_area1, "dialog_action_area1");
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_set_name (okbutton1, "okbutton1");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (Conf), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_set_name (cancelbutton1, "cancelbutton1");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (Conf), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
g_signal_connect ((gpointer) PAD1, "clicked",
G_CALLBACK (OnConf_Pad1),
NULL);
g_signal_connect ((gpointer) PAD2, "clicked",
G_CALLBACK (OnConf_Pad2),
NULL);
g_signal_connect ((gpointer) PAD3, "clicked",
G_CALLBACK (OnConf_Pad3),
NULL);
g_signal_connect ((gpointer) PAD4, "clicked",
G_CALLBACK (OnConf_Pad4),
NULL);
g_signal_connect ((gpointer) joydevicescombo, "changed",
G_CALLBACK (on_joydevicescombo_changed),
NULL);
g_signal_connect ((gpointer) Left, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Up, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Right, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Down, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) L2, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) L1, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Select, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Start, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) L3, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) R3, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Analog, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Square, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Triangle, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Circle, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Cross, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) R2, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) R1, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) L_Left, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Lx, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Ly, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) L_Down, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) L_Right, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) checkbutton_reverselx, "toggled",
G_CALLBACK (on_checkbutton_reverselx_toggled),
NULL);
g_signal_connect ((gpointer) R_Up, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) R_Left, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Rx, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) Ry, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) R_Right, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) R_Down, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) forcefeedback, "toggled",
G_CALLBACK (on_forcefeedback_toggled),
NULL);
g_signal_connect ((gpointer) checkbutton_reverserx, "toggled",
G_CALLBACK (on_checkbutton_reverserx_toggled),
NULL);
g_signal_connect ((gpointer) checkbutton_reversery, "toggled",
G_CALLBACK (on_checkbutton_reversery_toggled),
NULL);
g_signal_connect ((gpointer) checkbutton_reversely, "toggled",
G_CALLBACK (on_checkbutton_reversely_toggled),
NULL);
g_signal_connect ((gpointer) L_Up, "clicked",
G_CALLBACK (OnConf_Key),
NULL);
g_signal_connect ((gpointer) clear_button, "clicked",
G_CALLBACK (on_Clear),
NULL);
g_signal_connect ((gpointer) remove_button, "clicked",
G_CALLBACK (on_Remove),
NULL);
g_signal_connect ((gpointer) okbutton1, "clicked",
G_CALLBACK (OnConf_Ok),
NULL);
g_signal_connect ((gpointer) cancelbutton1, "clicked",
G_CALLBACK (OnConf_Cancel),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (Conf, Conf, "Conf");
GLADE_HOOKUP_OBJECT_NO_REF (Conf, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (Conf, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (Conf, frame1, "frame1");
GLADE_HOOKUP_OBJECT (Conf, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (Conf, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (Conf, PAD1, "PAD1");
GLADE_HOOKUP_OBJECT (Conf, PAD2, "PAD2");
GLADE_HOOKUP_OBJECT (Conf, PAD3, "PAD3");
GLADE_HOOKUP_OBJECT (Conf, PAD4, "PAD4");
GLADE_HOOKUP_OBJECT (Conf, label2, "label2");
GLADE_HOOKUP_OBJECT (Conf, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (Conf, label5, "label5");
GLADE_HOOKUP_OBJECT (Conf, joydevicescombo, "joydevicescombo");
GLADE_HOOKUP_OBJECT (Conf, fixed1, "fixed1");
GLADE_HOOKUP_OBJECT (Conf, vbox3, "vbox3");
GLADE_HOOKUP_OBJECT (Conf, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT (Conf, fixed2, "fixed2");
GLADE_HOOKUP_OBJECT (Conf, fixed3, "fixed3");
GLADE_HOOKUP_OBJECT (Conf, Left, "Left");
GLADE_HOOKUP_OBJECT (Conf, Up, "Up");
GLADE_HOOKUP_OBJECT (Conf, Right, "Right");
GLADE_HOOKUP_OBJECT (Conf, Down, "Down");
GLADE_HOOKUP_OBJECT (Conf, L2, "L2");
GLADE_HOOKUP_OBJECT (Conf, L1, "L1");
GLADE_HOOKUP_OBJECT (Conf, Select, "Select");
GLADE_HOOKUP_OBJECT (Conf, Start, "Start");
GLADE_HOOKUP_OBJECT (Conf, L3, "L3");
GLADE_HOOKUP_OBJECT (Conf, R3, "R3");
GLADE_HOOKUP_OBJECT (Conf, Analog, "Analog");
GLADE_HOOKUP_OBJECT (Conf, Square, "Square");
GLADE_HOOKUP_OBJECT (Conf, Triangle, "Triangle");
GLADE_HOOKUP_OBJECT (Conf, Circle, "Circle");
GLADE_HOOKUP_OBJECT (Conf, Cross, "Cross");
GLADE_HOOKUP_OBJECT (Conf, R2, "R2");
GLADE_HOOKUP_OBJECT (Conf, R1, "R1");
GLADE_HOOKUP_OBJECT (Conf, label3, "label3");
GLADE_HOOKUP_OBJECT (Conf, label6, "label6");
GLADE_HOOKUP_OBJECT (Conf, L_Left, "L_Left");
GLADE_HOOKUP_OBJECT (Conf, Lx, "Lx");
GLADE_HOOKUP_OBJECT (Conf, Ly, "Ly");
GLADE_HOOKUP_OBJECT (Conf, L_Down, "L_Down");
GLADE_HOOKUP_OBJECT (Conf, L_Right, "L_Right");
GLADE_HOOKUP_OBJECT (Conf, checkbutton_reverselx, "checkbutton_reverselx");
GLADE_HOOKUP_OBJECT (Conf, R_Up, "R_Up");
GLADE_HOOKUP_OBJECT (Conf, R_Left, "R_Left");
GLADE_HOOKUP_OBJECT (Conf, Rx, "Rx");
GLADE_HOOKUP_OBJECT (Conf, Ry, "Ry");
GLADE_HOOKUP_OBJECT (Conf, R_Right, "R_Right");
GLADE_HOOKUP_OBJECT (Conf, R_Down, "R_Down");
GLADE_HOOKUP_OBJECT (Conf, forcefeedback, "forcefeedback");
GLADE_HOOKUP_OBJECT (Conf, checkbutton_reverserx, "checkbutton_reverserx");
GLADE_HOOKUP_OBJECT (Conf, checkbutton_reversery, "checkbutton_reversery");
GLADE_HOOKUP_OBJECT (Conf, frame2, "frame2");
GLADE_HOOKUP_OBJECT (Conf, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT (Conf, scrolledwindow2, "scrolledwindow2");
GLADE_HOOKUP_OBJECT (Conf, padtreeview, "padtreeview");
GLADE_HOOKUP_OBJECT (Conf, label7, "label7");
GLADE_HOOKUP_OBJECT (Conf, checkbutton_reversely, "checkbutton_reversely");
GLADE_HOOKUP_OBJECT (Conf, L_Up, "L_Up");
GLADE_HOOKUP_OBJECT (Conf, clear_button, "clear_button");
GLADE_HOOKUP_OBJECT (Conf, remove_button, "remove_button");
GLADE_HOOKUP_OBJECT_NO_REF (Conf, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (Conf, okbutton1, "okbutton1");
GLADE_HOOKUP_OBJECT (Conf, cancelbutton1, "cancelbutton1");
return Conf;
}

6
plugins/onepad/Linux/interface.h
View File

@ -1,6 +0,0 @@
/*
* DO NOT EDIT THIS FILE - it is generated by Glade.
*/
GtkWidget* create_About (void);
GtkWidget* create_Conf (void);

214
plugins/onepad/Linux/linux.cpp
View File

@ -24,19 +24,38 @@
Display *GSdsp;
const char* s_pGuiKeyMap[] =
{
"L2", "R2", "L1", "R1",
"Triangle", "Circle", "Cross", "Square",
"Select", "L3", "R3", "Start",
"Up", "Right", "Down", "Left",
"Lx", "Rx", "Ly", "Ry",
"L_Up", "L_Right", "L_Down", "L_Left",
"R_Up", "R_Right", "R_Down", "R_Left"
};
extern string KeyName(int pad, int key);
extern void DisplayDialog();
void __forceinline SysMessage(const char *fmt, ...)
{
va_list list;
char msg[512];
va_start(list, fmt);
vsprintf(msg, fmt, list);
va_end(list);
if (msg[strlen(msg)-1] == '\n') msg[strlen(msg)-1] = 0;
GtkWidget *dialog;
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"%s", msg);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
EXPORT_C_(void) PADabout()
{
SysMessage("OnePad is a rewrite of Zerofrog's ZeroPad, done by arcum42.");
}
EXPORT_C_(s32) PADtest()
{
return 0;
}
s32 _PADopen(void *pDsp)
{
@ -199,178 +218,11 @@ EXPORT_C_(void) PADupdate(int pad)
}
}
void UpdateConf(int pad)
{
initLogging();
s_selectedpad = pad;
init_tree_view();
int i;
GtkWidget *Btn;
for (i = 0; i < ArraySize(s_pGuiKeyMap); i++)
{
if (s_pGuiKeyMap[i] == NULL) continue;
Btn = lookup_widget(Conf, s_pGuiKeyMap[i]);
if (Btn == NULL)
{
PAD_LOG("OnePAD: cannot find key %s\n", s_pGuiKeyMap[i]);
continue;
}
gtk_object_set_user_data(GTK_OBJECT(Btn), (void*)(MAX_KEYS * pad + i));
}
// check bounds
int joyid = _GetJoystickIdFromPAD(pad);
if (JoystickIdWithinBounds(joyid))
gtk_combo_box_set_active(GTK_COMBO_BOX(s_devicecombo), joyid); // select the combo
else
gtk_combo_box_set_active(GTK_COMBO_BOX(s_devicecombo), s_vjoysticks.size()); // no gamepad
int padopts = conf.options >> (16 * pad);
set_checked(Conf, "checkbutton_reverselx", padopts & PADOPTION_REVERTLX);
set_checked(Conf, "checkbutton_reversely", padopts & PADOPTION_REVERTLY);
set_checked(Conf, "checkbutton_reverserx", padopts & PADOPTION_REVERTRX);
set_checked(Conf, "checkbutton_reversery", padopts & PADOPTION_REVERTRY);
set_checked(Conf, "forcefeedback", padopts & PADOPTION_FORCEFEEDBACK);
}
int GetLabelId(GtkWidget *label)
{
if (label == NULL)
{
PAD_LOG("couldn't find correct label\n");
return -1;
}
return (int)(uptr)gtk_object_get_user_data(GTK_OBJECT(label));
}
void OnConf_Key(GtkButton *button, gpointer user_data)
{
bool captured = false;
const char* buttonname = gtk_widget_get_name(GTK_WIDGET(button));
GtkWidget* label = lookup_widget(Conf, buttonname);
int id = GetLabelId(label);
if (id == -1) return;
int pad = id / MAX_KEYS;
int key = id % MAX_KEYS;
// save the joystick states
UpdateJoysticks();
while (!captured)
{
vector<JoystickInfo*>::iterator itjoy;
char *tmp;
u32 pkey = get_key(pad, key);
if (PollX11Keyboard(tmp, pkey))
{
set_key(pad, key, pkey);
PAD_LOG("%s\n", KeyName(pad, key).c_str());
captured = true;
break;
}
SDL_JoystickUpdate();
itjoy = s_vjoysticks.begin();
while ((itjoy != s_vjoysticks.end()) && (!captured))
{
int button_id, direction;
pkey = get_key(pad, key);
if ((*itjoy)->PollButtons(button_id, pkey))
{
set_key(pad, key, pkey);
PAD_LOG("%s\n", KeyName(pad, key).c_str());
captured = true;
break;
}
bool sign = false;
bool pov = (!((key == PAD_RY) || (key == PAD_LY) || (key == PAD_RX) || (key == PAD_LX)));
int axis_id;
if (pov)
{
if ((*itjoy)->PollPOV(axis_id, sign, pkey))
{
set_key(pad, key, pkey);
PAD_LOG("%s\n", KeyName(pad, key).c_str());
captured = true;
break;
}
}
else
{
if ((*itjoy)->PollAxes(axis_id, pkey))
{
set_key(pad, key, pkey);
PAD_LOG("%s\n", KeyName(pad, key).c_str());
captured = true;
break;
}
}
if ((*itjoy)->PollHats(axis_id, direction, pkey))
{
set_key(pad, key, pkey);
PAD_LOG("%s\n", KeyName(pad, key).c_str());
captured = true;
break;
}
itjoy++;
}
}
init_tree_view();
}
void populate_joysticks()
{
// recreate
JoystickInfo::EnumerateJoysticks(s_vjoysticks);
s_devicecombo = lookup_widget(Conf, "joydevicescombo");
// fill the combo
char str[255];
vector<JoystickInfo*>::iterator it = s_vjoysticks.begin();
// Delete everything in the vector vjoysticks.
while (it != s_vjoysticks.end())
{
sprintf(str, "%d: %s - but: %d, axes: %d, hats: %d", (*it)->GetId(), (*it)->GetName().c_str(),
(*it)->GetNumButtons(), (*it)->GetNumAxes(), (*it)->GetNumHats());
gtk_combo_box_append_text(GTK_COMBO_BOX(s_devicecombo), str);
it++;
}
gtk_combo_box_append_text(GTK_COMBO_BOX(s_devicecombo), "No Gamepad");
UpdateConf(0);
}
EXPORT_C_(void) PADconfigure()
{
LoadConfig();
//DisplayDialog();
//return;
Conf = create_Conf();
populate_joysticks();
gtk_widget_show_all(Conf);
gtk_main();
DisplayDialog();
return;
}

7
plugins/onepad/Linux/linux.h
View File

@ -36,9 +36,4 @@ extern "C"
#include "callbacks.h"
}
extern GtkWidget *Conf, *s_devicecombo;
extern void init_tree_view();
extern void destroy_tree_view();
#define is_checked(main_widget, widget_name) (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lookup_widget(main_widget, widget_name))))
#define set_checked(main_widget,widget_name, state) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(lookup_widget(main_widget, widget_name)), state)
extern void DisplayDialog();

1154
plugins/onepad/Linux/onepad.glade
View File

File diff suppressed because it is too large Load Diff

12
plugins/onepad/Linux/onepad.gladep
View File

@ -1,12 +0,0 @@
<?xml version="1.0" standalone="no"?> <!--*- mode: xml -*-->
<!DOCTYPE glade-project SYSTEM "http://glade.gnome.org/glade-project-2.0.dtd">
<glade-project>
<name>Linux</name>
<program_name>linux</program_name>
<gnome_support>FALSE</gnome_support>
<use_widget_names>TRUE</use_widget_names>
<output_main_file>FALSE</output_main_file>
<output_build_files>FALSE</output_build_files>
<backup_source_files>FALSE</backup_source_files>
</glade-project>

144
plugins/onepad/Linux/support.c
View File

@ -1,144 +0,0 @@
/*
* DO NOT EDIT THIS FILE - it is generated by Glade.
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <gtk/gtk.h>
#include "support.h"
GtkWidget*
lookup_widget (GtkWidget *widget,
const gchar *widget_name)
{
GtkWidget *parent, *found_widget;
for (;;)
{
if (GTK_IS_MENU (widget))
parent = gtk_menu_get_attach_widget (GTK_MENU (widget));
else
parent = widget->parent;
if (!parent)
parent = (GtkWidget*) g_object_get_data (G_OBJECT (widget), "GladeParentKey");
if (parent == NULL)
break;
widget = parent;
}
found_widget = (GtkWidget*) g_object_get_data (G_OBJECT (widget),
widget_name);
if (!found_widget)
g_warning ("Widget not found: %s", widget_name);
return found_widget;
}
static GList *pixmaps_directories = NULL;
/* Use this function to set the directory containing installed pixmaps. */
void
add_pixmap_directory (const gchar *directory)
{
pixmaps_directories = g_list_prepend (pixmaps_directories,
g_strdup (directory));
}
/* This is an internally used function to find pixmap files. */
static gchar*
find_pixmap_file (const gchar *filename)
{
GList *elem;
/* We step through each of the pixmaps directory to find it. */
elem = pixmaps_directories;
while (elem)
{
gchar *pathname = g_strdup_printf ("%s%s%s", (gchar*)elem->data,
G_DIR_SEPARATOR_S, filename);
if (g_file_test (pathname, G_FILE_TEST_EXISTS))
return pathname;
g_free (pathname);
elem = elem->next;
}
return NULL;
}
/* This is an internally used function to create pixmaps. */
GtkWidget*
create_pixmap (GtkWidget *widget,
const gchar *filename)
{
gchar *pathname = NULL;
GtkWidget *pixmap;
if (!filename || !filename[0])
return gtk_image_new ();
pathname = find_pixmap_file (filename);
if (!pathname)
{
g_warning (_("Couldn't find pixmap file: %s"), filename);
return gtk_image_new ();
}
pixmap = gtk_image_new_from_file (pathname);
g_free (pathname);
return pixmap;
}
/* This is an internally used function to create pixmaps. */
GdkPixbuf*
create_pixbuf (const gchar *filename)
{
gchar *pathname = NULL;
GdkPixbuf *pixbuf;
GError *error = NULL;
if (!filename || !filename[0])
return NULL;
pathname = find_pixmap_file (filename);
if (!pathname)
{
g_warning (_("Couldn't find pixmap file: %s"), filename);
return NULL;
}
pixbuf = gdk_pixbuf_new_from_file (pathname, &error);
if (!pixbuf)
{
fprintf (stderr, "Failed to load pixbuf file: %s: %s\n",
pathname, error->message);
g_error_free (error);
}
g_free (pathname);
return pixbuf;
}
/* This is used to set ATK action descriptions. */
void
glade_set_atk_action_description (AtkAction *action,
const gchar *action_name,
const gchar *description)
{
gint n_actions, i;
n_actions = atk_action_get_n_actions (action);
for (i = 0; i < n_actions; i++)
{
if (!strcmp (atk_action_get_name (action, i), action_name))
atk_action_set_description (action, i, description);
}
}

69
plugins/onepad/Linux/support.h
View File

@ -1,69 +0,0 @@
/*
* DO NOT EDIT THIS FILE - it is generated by Glade.
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <gtk/gtk.h>
/*
* Standard gettext macros.
*/
#ifdef ENABLE_NLS
# include <libintl.h>
# undef _
# define _(String) dgettext (PACKAGE, String)
# define Q_(String) g_strip_context ((String), gettext (String))
# ifdef gettext_noop
# define N_(String) gettext_noop (String)
# else
# define N_(String) (String)
# endif
#else
# define textdomain(String) (String)
# define gettext(String) (String)
# define dgettext(Domain,Message) (Message)
# define dcgettext(Domain,Message,Type) (Message)
# define bindtextdomain(Domain,Directory) (Domain)
# define _(String) (String)
# define Q_(String) g_strip_context ((String), (String))
# define N_(String) (String)
#endif
/*
* Public Functions.
*/
/*
* This function returns a widget in a component created by Glade.
* Call it with the toplevel widget in the component (i.e. a window/dialog),
* or alternatively any widget in the component, and the name of the widget
* you want returned.
*/
GtkWidget* lookup_widget (GtkWidget *widget,
const gchar *widget_name);
/* Use this function to set the directory containing installed pixmaps. */
void add_pixmap_directory (const gchar *directory);
/*
* Private Functions.
*/
/* This is used to create the pixmaps used in the interface. */
GtkWidget* create_pixmap (GtkWidget *widget,
const gchar *filename);
/* This is used to create the pixbufs used in the interface. */
GdkPixbuf* create_pixbuf (const gchar *filename);
/* This is used to set ATK action descriptions. */
void glade_set_atk_action_description (AtkAction *action,
const gchar *action_name,
const gchar *description);