Use Input preferences

And remove Mouse, Keyboard and Touchpad.

Userguide and localizations will need to be updated.

Change-Id: I4543b2b63367cd13562c542610bad34b5934b103
Reviewed-on: https://review.haiku-os.org/c/haiku/+/2210
Reviewed-by: waddlesplash <[email protected]>
This commit is contained in:
Adrien Destugues
2020-02-08 17:03:19 +00:00
committed by waddlesplash
parent 4c8c060bc4
commit 445de1d348
33 changed files with 3 additions and 3619 deletions
+3 -3
View File
@@ -66,12 +66,12 @@ SYSTEM_PREFERENCES = [ FFilterByBuildFeatures
Backgrounds
<preference>Deskbar
FileTypes
Keyboard Keymap
Input
Keymap
Locale
Mouse
Network Notifications
Screen Shortcuts
Time Touchpad <preference>Tracker
Time <preference>Tracker
VirtualMemory
] ;
-3
View File
@@ -8,12 +8,10 @@ SubInclude HAIKU_TOP src preferences deskbar ;
SubInclude HAIKU_TOP src preferences filetypes ;
SubInclude HAIKU_TOP src preferences input ;
SubInclude HAIKU_TOP src preferences joysticks ;
SubInclude HAIKU_TOP src preferences keyboard ;
SubInclude HAIKU_TOP src preferences keymap ;
SubInclude HAIKU_TOP src preferences locale ;
SubInclude HAIKU_TOP src preferences mail ;
SubInclude HAIKU_TOP src preferences media ;
SubInclude HAIKU_TOP src preferences mouse ;
SubInclude HAIKU_TOP src preferences network ;
SubInclude HAIKU_TOP src preferences notifications ;
SubInclude HAIKU_TOP src preferences printers ;
@@ -23,6 +21,5 @@ SubInclude HAIKU_TOP src preferences screensaver ;
SubInclude HAIKU_TOP src preferences shortcuts ;
SubInclude HAIKU_TOP src preferences sounds ;
SubInclude HAIKU_TOP src preferences time ;
SubInclude HAIKU_TOP src preferences touchpad ;
SubInclude HAIKU_TOP src preferences tracker ;
SubInclude HAIKU_TOP src preferences virtualmemory ;
-25
View File
@@ -1,25 +0,0 @@
SubDir HAIKU_TOP src preferences keyboard ;
if ! $(TARGET_PLATFORM_HAIKU_COMPATIBLE) {
SubDirC++Flags -DCOMPILE_FOR_R5 ;
# SubDirC++Flags -fmultiple-symbol-spaces ;
}
UsePrivateHeaders input ;
Preference Keyboard :
Keyboard.cpp
KeyboardSettings.cpp
KeyboardView.cpp
KeyboardWindow.cpp
: translation be [ TargetLibsupc++ ] localestub
: Keyboard.rdef
;
DoCatalogs Keyboard :
x-vnd.Haiku-Keyboard
:
Keyboard.cpp
KeyboardWindow.cpp
KeyboardView.cpp
;
-71
View File
@@ -1,71 +0,0 @@
/*
* Copyright 2004-2006, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors in chronological order:
* Andrew McCall, [email protected]
* Jérôme Duval
* Marcus Overhagen
*/
#include "Keyboard.h"
#include "KeyboardWindow.h"
#include "KeyboardMessages.h"
#include <Alert.h>
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "KeyboardApplication"
KeyboardApplication::KeyboardApplication()
: BApplication("application/x-vnd.Haiku-Keyboard")
{
new KeyboardWindow();
}
void
KeyboardApplication::MessageReceived(BMessage* message)
{
switch (message->what) {
case ERROR_DETECTED:
{
BAlert* errorAlert = new BAlert("Error",
B_TRANSLATE("Something has gone wrong!"),
B_TRANSLATE("OK"), NULL, NULL,
B_WIDTH_AS_USUAL, B_OFFSET_SPACING, B_WARNING_ALERT);
errorAlert->SetFlags(errorAlert->Flags() | B_CLOSE_ON_ESCAPE);
errorAlert->Go();
be_app->PostMessage(B_QUIT_REQUESTED);
break;
}
default:
BApplication::MessageReceived(message);
break;
}
}
void
KeyboardApplication::AboutRequested()
{
BAlert* alert = new BAlert("about",
B_TRANSLATE("Written by Andrew Edward McCall"), B_TRANSLATE("OK"));
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
}
// #pragma mark -
int
main(int, char**)
{
KeyboardApplication app;
app.Run();
return 0;
}
-26
View File
@@ -1,26 +0,0 @@
/*
* Copyright 2004-2006, the Haiku project. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors in chronological order:
* [email protected]
* Jérôme Duval
* Marcus Overhagen
*/
#ifndef KEYBOARD_H
#define KEYBOARD_H
#include <Application.h>
#include <Catalog.h>
#include <Locale.h>
class KeyboardApplication : public BApplication
{
public:
KeyboardApplication();
void MessageReceived(BMessage* message);
void AboutRequested(void);
};
#endif
-38
View File
@@ -1,38 +0,0 @@
resource app_signature "application/x-vnd.Haiku-Keyboard";
resource app_name_catalog_entry "x-vnd.Haiku-Keyboard:System name:Keyboard";
resource app_flags B_SINGLE_LAUNCH;
resource app_version {
major = 1,
middle = 0,
minor = 0,
/* 0 = development 1 = alpha 2 = beta
3 = gamma 4 = golden master 5 = final */
variety = 2,
internal = 0,
short_info = "Keyboard",
long_info = "Keyboard ©2004-2009 Haiku"
};
resource vector_icon {
$"6E63696605020016023910813A2974BB43733A501C4A60D94AC7F400E9FFB902"
$"001602B8513BB55C0A38B9DABBC2B74A98024B8D270066FF9002011603BC39E2"
$"364286B516B5BB0AE64ACEF94A7E0500FF56E5FFC1050004006D0A0202372D34"
$"2B3A2F3C2A3F2C39280802392C3B2F0805493046344A334A364F3308032C3C32"
$"39303E08022F3B313C00043E443E443D4542454146434440423F434141444345"
$"4243440A04425C4CCA1B56C61F4E490A0432523647424C425A0A04425A424C4C"
$"434E4E0A043647424C4C43403E160A030309080730180801178322040A000107"
$"2018080A0101082018080A0201092018080A030200011001178100040A040106"
$"2028100A030309080730281001178322040A0001072028100A0101082028100A"
$"0201092028100A0301021001178122040A030309080730101801178422040A00"
$"01072010180A0101082010180A0201092010180A030203041001178100040A04"
$"0106000A03030908071001178322040A000107000A010108000A020109000A03"
$"0105100117810004"
};
@@ -1,24 +0,0 @@
/*
* Copyright 2004-2007, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Andrew McCall, [email protected]
* Jérôme Duval
* Marcus Overhagen
*/
#ifndef KEYBOARD_MESSAGES_H
#define KEYBOARD_MESSAGES_H
#include <SupportDefs.h>
const uint32 BUTTON_DEFAULTS = 'BTde';
const uint32 BUTTON_REVERT = 'BTre';
const uint32 SLIDER_REPEAT_RATE = 'SLrr';
const uint32 SLIDER_DELAY_RATE = 'SLdr';
const uint32 ERROR_DETECTED = 'ERor';
#endif // KEYBOARD_MESSAGES_H
@@ -1,127 +0,0 @@
/*
* Copyright 2004-2006, the Haiku project. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors in chronological order:
* [email protected]
* Jérôme Duval
* Marcus Overhagen
*/
#include <FindDirectory.h>
#include <File.h>
#include <Path.h>
#include <stdio.h>
#include "KeyboardSettings.h"
// Keyboard setting file layout is like this:
// struct {
// struct kb_settings; // managed by input server
// BPoint corner; // used by pref app
// }
KeyboardSettings::KeyboardSettings()
{
if (get_key_repeat_rate(&fSettings.key_repeat_rate) != B_OK)
fSettings.key_repeat_rate = kb_default_key_repeat_rate;
if (get_key_repeat_delay(&fSettings.key_repeat_delay) != B_OK)
fSettings.key_repeat_delay = kb_default_key_repeat_delay;
fOriginalSettings = fSettings;
BPath path;
BFile file;
fCorner.x = 150;
fCorner.y = 100;
status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
if (status == B_OK) {
status = path.Append(kb_settings_file);
if (status == B_OK) {
status = file.SetTo(path.Path(), B_READ_ONLY);
if (status == B_OK) {
if (file.ReadAt(sizeof(kb_settings), &fCorner, sizeof(fCorner)) != sizeof(fCorner)) {
fCorner.x = 150;
fCorner.y = 100;
}
}
}
}
}
KeyboardSettings::~KeyboardSettings()
{
BPath path;
BFile file;
if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) < B_OK)
return;
if (path.Append(kb_settings_file) < B_OK)
return;
// be careful: don't create the file if it doesn't already exist
if (file.SetTo(path.Path(), B_WRITE_ONLY) < B_OK)
return;
file.WriteAt(sizeof(kb_settings), &fCorner, sizeof(fCorner));
}
void
KeyboardSettings::SetWindowCorner(BPoint corner)
{
fCorner = corner;
}
void
KeyboardSettings::SetKeyboardRepeatRate(int32 rate)
{
if (set_key_repeat_rate(rate) != B_OK)
fprintf(stderr, "error while set_key_repeat_rate!\n");
fSettings.key_repeat_rate = rate;
}
void
KeyboardSettings::SetKeyboardRepeatDelay(bigtime_t delay)
{
if (set_key_repeat_delay(delay) != B_OK)
fprintf(stderr, "error while set_key_repeat_delay!\n");
fSettings.key_repeat_delay = delay;
}
void
KeyboardSettings::Dump()
{
printf("repeat rate: %" B_PRId32 "\n", fSettings.key_repeat_rate);
printf("repeat delay: %" B_PRId64 "\n", fSettings.key_repeat_delay);
}
void
KeyboardSettings::Revert()
{
SetKeyboardRepeatDelay(fOriginalSettings.key_repeat_delay);
SetKeyboardRepeatRate(fOriginalSettings.key_repeat_rate);
}
void
KeyboardSettings::Defaults()
{
SetKeyboardRepeatDelay(kb_default_key_repeat_delay);
SetKeyboardRepeatRate(kb_default_key_repeat_rate);
}
bool
KeyboardSettings::IsDefaultable()
{
return fSettings.key_repeat_delay != kb_default_key_repeat_delay
|| fSettings.key_repeat_rate != kb_default_key_repeat_rate;
}
@@ -1,43 +0,0 @@
/*
* Copyright 2004-2006, the Haiku project. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors in chronological order:
* [email protected]
* Jérôme Duval
* Marcus Overhagen
*/
#ifndef KEYBOARD_SETTINGS_H_
#define KEYBOARD_SETTINGS_H_
#include <SupportDefs.h>
#include "kb_mouse_settings.h"
class KeyboardSettings{
public :
KeyboardSettings();
~KeyboardSettings();
void Dump();
void Revert();
void Defaults();
bool IsDefaultable();
BPoint WindowCorner() const { return fCorner; }
void SetWindowCorner(BPoint corner);
int32 KeyboardRepeatRate() const
{ return fSettings.key_repeat_rate; }
void SetKeyboardRepeatRate(int32 rate);
bigtime_t KeyboardRepeatDelay() const
{ return fSettings.key_repeat_delay; }
void SetKeyboardRepeatDelay(bigtime_t delay);
private:
BPoint fCorner;
kb_settings fSettings;
kb_settings fOriginalSettings;
};
#endif
-93
View File
@@ -1,93 +0,0 @@
/*
* Copyright 2004-2006, the Haiku project. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors in chronological order:
* [email protected]
* Jérôme Duval
* Marcus Overhagen
*/
#include <InterfaceDefs.h>
#include <TranslationUtils.h>
#include <Bitmap.h>
#include <Button.h>
#include <Catalog.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <Slider.h>
#include <TextControl.h>
#include <Window.h>
#include "KeyboardView.h"
#include "KeyboardMessages.h"
#include "KeyboardSettings.h"
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "KeyboardView"
KeyboardView::KeyboardView()
: BGroupView()
{
fIconBitmap = BTranslationUtils::GetBitmap("key_bmap");
fClockBitmap = BTranslationUtils::GetBitmap("clock_bmap");
// Create the "Key repeat rate" slider...
fRepeatSlider = new BSlider("key_repeat_rate",
B_TRANSLATE("Key repeat rate"),
new BMessage(SLIDER_REPEAT_RATE),
20, 300, B_HORIZONTAL);
fRepeatSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fRepeatSlider->SetHashMarkCount(5);
fRepeatSlider->SetLimitLabels(B_TRANSLATE("Slow"),B_TRANSLATE("Fast"));
fRepeatSlider->SetExplicitMinSize(BSize(200, B_SIZE_UNSET));
// Create the "Delay until key repeat" slider...
fDelaySlider = new BSlider("delay_until_key_repeat",
B_TRANSLATE("Delay until key repeat"),
new BMessage(SLIDER_DELAY_RATE),
250000, 1000000, B_HORIZONTAL);
fDelaySlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fDelaySlider->SetHashMarkCount(4);
fDelaySlider->SetLimitLabels(B_TRANSLATE("Short"),B_TRANSLATE("Long"));
// Create the "Typing test area" text box...
BTextControl* textcontrol = new BTextControl(NULL,
B_TRANSLATE("Typing test area"),
new BMessage('TTEA'));
textcontrol->SetAlignment(B_ALIGN_LEFT, B_ALIGN_CENTER);
textcontrol->SetExplicitMinSize(BSize(
textcontrol->StringWidth(B_TRANSLATE("Typing test area")), B_SIZE_UNSET));
// Build the layout
BLayoutBuilder::Group<>(this, B_VERTICAL, B_USE_DEFAULT_SPACING)
.Add(fRepeatSlider)
.Add(fDelaySlider)
.Add(textcontrol);
}
KeyboardView::~KeyboardView()
{
}
void
KeyboardView::Draw(BRect updateFrame)
{
BPoint pt;
pt.x = fRepeatSlider->Frame().right + 10;
if (fIconBitmap != NULL) {
pt.y = fRepeatSlider->Frame().bottom - 35
- fIconBitmap->Bounds().Height() / 3;
DrawBitmap(fIconBitmap, pt);
}
if (fClockBitmap != NULL) {
pt.y = fDelaySlider->Frame().bottom - 35
- fClockBitmap->Bounds().Height() / 3;
DrawBitmap(fClockBitmap, pt);
}
}
-35
View File
@@ -1,35 +0,0 @@
/*
* Copyright 2004-2006, the Haiku project. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors in chronological order:
* [email protected]
* Jérôme Duval
* Marcus Overhagen
*/
#ifndef KEYBOARD_VIEW_H
#define KEYBOARD_VIEW_H
#include <GroupView.h>
#include <Slider.h>
#include <SupportDefs.h>
#include <InterfaceDefs.h>
#include <Application.h>
class KeyboardView : public BGroupView
{
public:
KeyboardView();
virtual ~KeyboardView();
void Draw(BRect frame);
private:
BBitmap *fIconBitmap;
BBitmap *fClockBitmap;
BSlider *fDelaySlider;
BSlider *fRepeatSlider;
};
#endif
-188
View File
@@ -1,188 +0,0 @@
/*
* Copyright 2004-2007, Haiku. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Andrew McCall, [email protected]
* Jérôme Duval
* Marcus Overhagen
*/
#include "KeyboardMessages.h"
#include "KeyboardView.h"
#include "KeyboardWindow.h"
#include <Box.h>
#include <Button.h>
#include <Catalog.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <Message.h>
#include <Screen.h>
#include <SeparatorView.h>
#include <Slider.h>
#include <TextControl.h>
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "KeyboardWindow"
KeyboardWindow::KeyboardWindow()
:
BWindow(BRect(0, 0, 200, 200), B_TRANSLATE_SYSTEM_NAME("Keyboard"),
B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE
| B_ASYNCHRONOUS_CONTROLS | B_AUTO_UPDATE_SIZE_LIMITS)
{
MoveTo(fSettings.WindowCorner());
// Add the main settings view
fSettingsView = new KeyboardView();
// Add the "Default" button..
fDefaultsButton = new BButton(B_TRANSLATE("Defaults"), new BMessage(BUTTON_DEFAULTS));
// Add the "Revert" button...
fRevertButton = new BButton(B_TRANSLATE("Revert"), new BMessage(BUTTON_REVERT));
fRevertButton->SetEnabled(false);
// Build the layout
BLayoutBuilder::Group<>(this, B_VERTICAL)
.AddGroup(B_HORIZONTAL)
.SetInsets(B_USE_WINDOW_SPACING, B_USE_WINDOW_SPACING,
B_USE_WINDOW_SPACING, 0)
.Add(fSettingsView)
.End()
.Add(new BSeparatorView(B_HORIZONTAL))
.AddGroup(B_HORIZONTAL)
.SetInsets(B_USE_WINDOW_SPACING, 0, B_USE_WINDOW_SPACING,
B_USE_WINDOW_SPACING)
.Add(fDefaultsButton)
.Add(fRevertButton)
.End();
BSlider* slider = (BSlider* )FindView("key_repeat_rate");
if (slider !=NULL)
slider->SetValue(fSettings.KeyboardRepeatRate());
slider = (BSlider* )FindView("delay_until_key_repeat");
if (slider !=NULL)
slider->SetValue(fSettings.KeyboardRepeatDelay());
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
// center window if it would be off-screen
BScreen screen;
if (screen.Frame().right < Frame().right
|| screen.Frame().bottom < Frame().bottom) {
CenterOnScreen();
}
#ifdef DEBUG
fSettings.Dump();
#endif
Show();
}
bool
KeyboardWindow::QuitRequested()
{
fSettings.SetWindowCorner(Frame().LeftTop());
#ifdef DEBUG
fSettings.Dump();
#endif
be_app->PostMessage(B_QUIT_REQUESTED);
return true;
}
void
KeyboardWindow::MessageReceived(BMessage* message)
{
BSlider* slider = NULL;
switch (message->what) {
case BUTTON_DEFAULTS:
{
fSettings.Defaults();
slider = (BSlider* )FindView("key_repeat_rate");
if (slider !=NULL)
slider->SetValue(fSettings.KeyboardRepeatRate());
slider = (BSlider* )FindView("delay_until_key_repeat");
if (slider !=NULL)
slider->SetValue(fSettings.KeyboardRepeatDelay());
fDefaultsButton->SetEnabled(false);
fRevertButton->SetEnabled(true);
break;
}
case BUTTON_REVERT:
{
fSettings.Revert();
slider = (BSlider* )FindView("key_repeat_rate");
if (slider !=NULL)
slider->SetValue(fSettings.KeyboardRepeatRate());
slider = (BSlider* )FindView("delay_until_key_repeat");
if (slider !=NULL)
slider->SetValue(fSettings.KeyboardRepeatDelay());
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(false);
break;
}
case SLIDER_REPEAT_RATE:
{
int32 rate;
if (message->FindInt32("be:value", &rate) != B_OK)
break;
fSettings.SetKeyboardRepeatRate(rate);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(true);
break;
}
case SLIDER_DELAY_RATE:
{
int32 delay;
if (message->FindInt32("be:value", &delay) != B_OK)
break;
// We need to look at the value from the slider and make it "jump"
// to the next notch along. Setting the min and max values of the
// slider to 1 and 4 doesn't work like the real Keyboard app.
if (delay < 375000)
delay = 250000;
if (delay >= 375000 && delay < 625000)
delay = 500000;
if (delay >= 625000 && delay < 875000)
delay = 750000;
if (delay >= 875000)
delay = 1000000;
fSettings.SetKeyboardRepeatDelay(delay);
slider = (BSlider* )FindView("delay_until_key_repeat");
if (slider != NULL)
slider->SetValue(delay);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(true);
break;
}
default:
BWindow::MessageReceived(message);
break;
}
}
-34
View File
@@ -1,34 +0,0 @@
/*
* Copyright 2004-2006, the Haiku project. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors in chronological order:
* [email protected]
* Jérôme Duval
* Marcus Overhagen
*/
#ifndef KEYBOARD_WINDOW_H
#define KEYBOARD_WINDOW_H
#include <Button.h>
#include <Window.h>
#include "KeyboardSettings.h"
#include "KeyboardView.h"
class KeyboardWindow : public BWindow
{
public:
KeyboardWindow();
bool QuitRequested();
void MessageReceived(BMessage* message);
private:
KeyboardView *fSettingsView;
KeyboardSettings fSettings;
BButton *fDefaultsButton;
BButton *fRevertButton;
};
#endif
-21
View File
@@ -1,21 +0,0 @@
SubDir HAIKU_TOP src preferences mouse ;
UsePrivateHeaders input ;
Preference Mouse :
Mouse.cpp
MouseSettings.cpp
MouseWindow.cpp
MouseView.cpp
SettingsView.cpp
: translation be [ TargetLibsupc++ ] localestub
: Mouse.rdef
;
DoCatalogs Mouse :
x-vnd.Haiku-Mouse
:
Mouse.cpp
MouseWindow.cpp
SettingsView.cpp
;
-54
View File
@@ -1,54 +0,0 @@
/*
* Copyright 2003-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
*/
#include "Mouse.h"
#include "MouseWindow.h"
#include <Alert.h>
#include <Screen.h>
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "MouseApplication"
const char* kSignature = "application/x-vnd.Haiku-Mouse";
MouseApplication::MouseApplication()
:
BApplication(kSignature)
{
BRect rect(0, 0, 397, 293);
MouseWindow *window = new MouseWindow(rect);
window->Show();
}
void
MouseApplication::AboutRequested()
{
BAlert* alert = new BAlert("about",
B_TRANSLATE("...by Andrew Edward McCall"), B_TRANSLATE("Dig Deal"));
alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
alert->Go();
}
// #pragma mark -
int
main(int /*argc*/, char ** /*argv*/)
{
MouseApplication app;
app.Run();
return 0;
}
-26
View File
@@ -1,26 +0,0 @@
/*
* Copyright 2003-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
*/
#ifndef MOUSE_H
#define MOUSE_H
#include <Application.h>
#include <Catalog.h>
#include <Locale.h>
class MouseApplication : public BApplication {
public:
MouseApplication();
virtual void AboutRequested();
};
#endif /* MOUSE_H */
-40
View File
@@ -1,40 +0,0 @@
resource app_signature "application/x-vnd.Haiku-Mouse";
resource app_name_catalog_entry "x-vnd.Haiku-Mouse:System name:Mouse";
resource app_flags B_SINGLE_LAUNCH;
resource app_version {
major = 1,
middle = 0,
minor = 0,
/* 0 = development 1 = alpha 2 = beta
3 = gamma 4 = golden master 5 = final */
variety = 2,
internal = 0,
short_info = "Mouse",
long_info = "Mouse ©2002-2009 Haiku"
};
resource vector_icon {
$"6E636966080301000002000202AC6DA33A810CBCBF0CAEA9C248C4E546BB2A00"
$"01000000FF010000FF020016023D2328BA287D3B40A23E5D334837CE48FA2500"
$"69FF01020116023E40000000000000003E400048000048000000FBFFC0020106"
$"02B832FBBACA8D3ACA8DB832FB48D3BB493902FFBEBEBE0001000005BE05FC01"
$"0100007D0604033E2C3C2436263E222E2E282E342E2802082C4CB5EDC39ABA27"
$"C5B7BFBFC883BD60C754C19AC9715052C4C9C842C722C5E9544EC6B5C656C90E"
$"C3FDC7B7C08BC992C179C558BF5C4038C21FBDBFBDE5BBA232BD5BBB83BC04B9"
$"2ABE5DB6FB42B7FDBF8AB5A4C1E30208475443544B54C6EB50C660C6ABC777C5"
$"9456C487C803C508C9DBC33056405842543E42334E3536312C3A3036283EB628"
$"C223B628C2232A4A344AB80EC27CBE0FC50F0604EE2E383838323638383B3635"
$"333B332F3304032F3049304930433A36BA1DBE14413141330606FE0B4659C487"
$"59C36B59C5605954C8E9C6D7C95AC91CC837CBD7C4FBCB67C614CC30C41DCAE7"
$"C289CBC8C2FAC983C1D75443080A070105000A0101001001178400040A000302"
$"01031001178422040A020101000A030102000A0001041001178100040A060104"
$"123FE3AA0000000000003FDFFC41DB9540107701178100040A04010300"
};
-33
View File
@@ -1,33 +0,0 @@
/*
* Copyright 2003-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
* Brecht Machiels ([email protected])
*/
#ifndef MOUSE_CONSTANTS_H
#define MOUSE_CONSTANTS_H
// interface messages
const uint32 kMsgDefaults = 'BTde';
const uint32 kMsgRevert = 'BTre';
const uint32 kMsgMouseType = 'PUmt';
const uint32 kMsgMouseFocusMode = 'PUmf';
const uint32 kMsgFollowsMouseMode = 'PUff';
const uint32 kMsgAcceptFirstClick = 'PUaf';
const uint32 kMsgMouseMap = 'PUmm';
const uint32 kMsgDoubleClickSpeed = 'SLdc';
const uint32 kMsgMouseSpeed = 'SLms';
const uint32 kMsgAccelerationFactor = 'SLma';
// user interface
const uint32 kBorderSpace = 10;
const uint32 kItemSpace = 7;
#endif /* MOUSE_CONSTANTS_H */
-373
View File
@@ -1,373 +0,0 @@
/*
* Copyright 2003-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
* Brecht Machiels ([email protected])
*/
#include <FindDirectory.h>
#include <File.h>
#include <Path.h>
#include <View.h>
#include <stdio.h>
#include "MouseSettings.h"
// The R5 settings file differs from that of OpenBeOS;
// the latter maps 16 different mouse buttons
#define R5_COMPATIBLE 1
static const bigtime_t kDefaultClickSpeed = 500000;
static const int32 kDefaultMouseSpeed = 65536;
static const int32 kDefaultMouseType = 3; // 3 button mouse
static const int32 kDefaultAccelerationFactor = 65536;
static const bool kDefaultAcceptFirstClick = false;
MouseSettings::MouseSettings()
:
fWindowPosition(-1, -1)
{
_RetrieveSettings();
fOriginalSettings = fSettings;
fOriginalMode = fMode;
fOriginalFocusFollowsMouseMode = fFocusFollowsMouseMode;
fOriginalAcceptFirstClick = fAcceptFirstClick;
}
MouseSettings::~MouseSettings()
{
_SaveSettings();
}
status_t
MouseSettings::_GetSettingsPath(BPath &path)
{
status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
if (status < B_OK)
return status;
path.Append(mouse_settings_file);
return B_OK;
}
void
MouseSettings::_RetrieveSettings()
{
// retrieve current values
if (get_mouse_map(&fSettings.map) != B_OK)
fprintf(stderr, "error when get_mouse_map\n");
if (get_click_speed(&fSettings.click_speed) != B_OK)
fprintf(stderr, "error when get_click_speed\n");
if (get_mouse_speed(&fSettings.accel.speed) != B_OK)
fprintf(stderr, "error when get_mouse_speed\n");
if (get_mouse_acceleration(&fSettings.accel.accel_factor) != B_OK)
fprintf(stderr, "error when get_mouse_acceleration\n");
if (get_mouse_type(&fSettings.type) != B_OK)
fprintf(stderr, "error when get_mouse_type\n");
fMode = mouse_mode();
fFocusFollowsMouseMode = focus_follows_mouse_mode();
fAcceptFirstClick = accept_first_click();
// also try to load the window position from disk
BPath path;
if (_GetSettingsPath(path) < B_OK)
return;
BFile file(path.Path(), B_READ_ONLY);
if (file.InitCheck() < B_OK)
return;
#if R5_COMPATIBLE
const off_t kOffset = sizeof(mouse_settings) - sizeof(mouse_map)
+ sizeof(int32) * 3;
// we have to do this because mouse_map counts 16 buttons in OBOS
#else
const off_t kOffset = sizeof(mouse_settings);
#endif
if (file.ReadAt(kOffset, &fWindowPosition, sizeof(BPoint))
!= sizeof(BPoint)) {
// set default window position (invalid positions will be
// corrected by the application; the window will be centered
// in this case)
fWindowPosition.x = -1;
fWindowPosition.y = -1;
}
#ifdef DEBUG
Dump();
#endif
}
status_t
MouseSettings::_SaveSettings()
{
BPath path;
status_t status = _GetSettingsPath(path);
if (status < B_OK)
return status;
BFile file(path.Path(), B_READ_WRITE | B_CREATE_FILE);
status = file.InitCheck();
if (status < B_OK)
return status;
#if R5_COMPATIBLE
const off_t kOffset = sizeof(mouse_settings) - sizeof(mouse_map)
+ sizeof(int32) * 3;
// we have to do this because mouse_map counts 16 buttons in OBOS
#else
const off_t kOffset = sizeof(mouse_settings);
#endif
file.WriteAt(kOffset, &fWindowPosition, sizeof(BPoint));
return B_OK;
}
#ifdef DEBUG
void
MouseSettings::Dump()
{
printf("type:\t\t%" B_PRId32 " button mouse\n", fSettings.type);
printf("map:\t\tleft = %" B_PRIu32 " : middle = %" B_PRIu32 " : right = %"
B_PRIu32 "\n", fSettings.map.button[0], fSettings.map.button[2],
fSettings.map.button[1]);
printf("click speed:\t%" B_PRId64 "\n", fSettings.click_speed);
printf("accel:\t\t%s\n", fSettings.accel.enabled ? "enabled" : "disabled");
printf("accel factor:\t%" B_PRId32 "\n", fSettings.accel.accel_factor);
printf("speed:\t\t%" B_PRId32 "\n", fSettings.accel.speed);
const char *mode = "unknown";
switch (fMode) {
case B_NORMAL_MOUSE:
mode = "click to focus and raise";
break;
case B_CLICK_TO_FOCUS_MOUSE:
mode = "click to focus";
break;
case B_FOCUS_FOLLOWS_MOUSE:
mode = "focus follows mouse";
break;
}
printf("mouse mode:\t%s\n", mode);
const char *focus_follows_mouse_mode = "unknown";
switch (fFocusFollowsMouseMode) {
case B_NORMAL_FOCUS_FOLLOWS_MOUSE:
focus_follows_mouse_mode = "normal";
break;
case B_WARP_FOCUS_FOLLOWS_MOUSE:
focus_follows_mouse_mode = "warp";
break;
case B_INSTANT_WARP_FOCUS_FOLLOWS_MOUSE:
focus_follows_mouse_mode = "instant warp";
break;
}
printf("focus follows mouse mode:\t%s\n", focus_follows_mouse_mode);
printf("accept first click:\t%s\n",
fAcceptFirstClick ? "enabled" : "disabled");
}
#endif
// Resets the settings to the system defaults
void
MouseSettings::Defaults()
{
SetClickSpeed(kDefaultClickSpeed);
SetMouseSpeed(kDefaultMouseSpeed);
SetMouseType(kDefaultMouseType);
SetAccelerationFactor(kDefaultAccelerationFactor);
SetMouseMode(B_NORMAL_MOUSE);
SetFocusFollowsMouseMode(B_NORMAL_FOCUS_FOLLOWS_MOUSE);
SetAcceptFirstClick(kDefaultAcceptFirstClick);
mouse_map map;
if (get_mouse_map(&map) == B_OK) {
map.button[0] = B_PRIMARY_MOUSE_BUTTON;
map.button[1] = B_SECONDARY_MOUSE_BUTTON;
map.button[2] = B_TERTIARY_MOUSE_BUTTON;
SetMapping(map);
}
}
// Checks if the settings are different then the system defaults
bool
MouseSettings::IsDefaultable()
{
return fSettings.click_speed != kDefaultClickSpeed
|| fSettings.accel.speed != kDefaultMouseSpeed
|| fSettings.type != kDefaultMouseType
|| fSettings.accel.accel_factor != kDefaultAccelerationFactor
|| fMode != B_NORMAL_MOUSE
|| fFocusFollowsMouseMode != B_NORMAL_FOCUS_FOLLOWS_MOUSE
|| fAcceptFirstClick != kDefaultAcceptFirstClick
|| fSettings.map.button[0] != B_PRIMARY_MOUSE_BUTTON
|| fSettings.map.button[1] != B_SECONDARY_MOUSE_BUTTON
|| fSettings.map.button[2] != B_TERTIARY_MOUSE_BUTTON;
}
// Reverts to the active settings at program startup
void
MouseSettings::Revert()
{
SetClickSpeed(fOriginalSettings.click_speed);
SetMouseSpeed(fOriginalSettings.accel.speed);
SetMouseType(fOriginalSettings.type);
SetAccelerationFactor(fOriginalSettings.accel.accel_factor);
SetMouseMode(fOriginalMode);
SetFocusFollowsMouseMode(fOriginalFocusFollowsMouseMode);
SetAcceptFirstClick(fOriginalAcceptFirstClick);
SetMapping(fOriginalSettings.map);
}
// Checks if the settings are different then the original settings
bool
MouseSettings::IsRevertable()
{
return fSettings.click_speed != fOriginalSettings.click_speed
|| fSettings.accel.speed != fOriginalSettings.accel.speed
|| fSettings.type != fOriginalSettings.type
|| fSettings.accel.accel_factor != fOriginalSettings.accel.accel_factor
|| fMode != fOriginalMode
|| fFocusFollowsMouseMode != fOriginalFocusFollowsMouseMode
|| fAcceptFirstClick != fOriginalAcceptFirstClick
|| fSettings.map.button[0] != fOriginalSettings.map.button[0]
|| fSettings.map.button[1] != fOriginalSettings.map.button[1]
|| fSettings.map.button[2] != fOriginalSettings.map.button[2];
}
void
MouseSettings::SetWindowPosition(BPoint corner)
{
fWindowPosition = corner;
}
void
MouseSettings::SetMouseType(int32 type)
{
if (set_mouse_type(type) == B_OK)
fSettings.type = type;
else
fprintf(stderr, "error when set_mouse_type\n");
}
bigtime_t
MouseSettings::ClickSpeed() const
{
return 1000000LL - fSettings.click_speed;
// to correct the Sliders 0-100000 scale
}
void
MouseSettings::SetClickSpeed(bigtime_t clickSpeed)
{
clickSpeed = 1000000LL - clickSpeed;
if (set_click_speed(clickSpeed) == B_OK)
fSettings.click_speed = clickSpeed;
else
fprintf(stderr, "error when set_click_speed\n");
}
void
MouseSettings::SetMouseSpeed(int32 speed)
{
if (set_mouse_speed(speed) == B_OK)
fSettings.accel.speed = speed;
else
fprintf(stderr, "error when set_mouse_speed\n");
}
void
MouseSettings::SetAccelerationFactor(int32 factor)
{
if (set_mouse_acceleration(factor) == B_OK)
fSettings.accel.accel_factor = factor;
else
fprintf(stderr, "error when set_mouse_acceleration\n");
}
uint32
MouseSettings::Mapping(int32 index) const
{
return fSettings.map.button[index];
}
void
MouseSettings::Mapping(mouse_map &map) const
{
map = fSettings.map;
}
void
MouseSettings::SetMapping(int32 index, uint32 button)
{
fSettings.map.button[index] = button;
if (set_mouse_map(&fSettings.map) != B_OK)
fprintf(stderr, "error when set_mouse_map\n");
}
void
MouseSettings::SetMapping(mouse_map &map)
{
if (set_mouse_map(&map) == B_OK)
fSettings.map = map;
else
fprintf(stderr, "error when set_mouse_map\n");
}
void
MouseSettings::SetMouseMode(mode_mouse mode)
{
set_mouse_mode(mode);
fMode = mode;
}
void
MouseSettings::SetFocusFollowsMouseMode(mode_focus_follows_mouse mode)
{
set_focus_follows_mouse_mode(mode);
fFocusFollowsMouseMode = mode;
}
void
MouseSettings::SetAcceptFirstClick(bool accept_first_click)
{
set_accept_first_click(accept_first_click);
fAcceptFirstClick = accept_first_click;
}
-79
View File
@@ -1,79 +0,0 @@
/*
* Copyright 2003-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
* Brecht Machiels ([email protected])
*/
#ifndef MOUSE_SETTINGS_H
#define MOUSE_SETTINGS_H
#include <InterfaceDefs.h>
#include <Point.h>
#include <SupportDefs.h>
#include "kb_mouse_settings.h"
class BPath;
class MouseSettings {
public:
MouseSettings();
~MouseSettings();
void Revert();
bool IsRevertable();
void Defaults();
bool IsDefaultable();
void Dump();
BPoint WindowPosition() const { return fWindowPosition; }
void SetWindowPosition(BPoint corner);
int32 MouseType() const { return fSettings.type; }
void SetMouseType(int32 type);
bigtime_t ClickSpeed() const;
void SetClickSpeed(bigtime_t click_speed);
int32 MouseSpeed() const { return fSettings.accel.speed; }
void SetMouseSpeed(int32 speed);
int32 AccelerationFactor() const { return fSettings.accel.accel_factor; }
void SetAccelerationFactor(int32 factor);
uint32 Mapping(int32 index) const;
void Mapping(mouse_map &map) const;
void SetMapping(int32 index, uint32 button);
void SetMapping(mouse_map &map);
mode_mouse MouseMode() const { return fMode; }
void SetMouseMode(mode_mouse mode);
mode_focus_follows_mouse FocusFollowsMouseMode() const {
return fFocusFollowsMouseMode;
}
void SetFocusFollowsMouseMode(mode_focus_follows_mouse mode);
bool AcceptFirstClick() const { return fAcceptFirstClick; }
void SetAcceptFirstClick(bool accept_first_click);
private:
static status_t _GetSettingsPath(BPath &path);
void _RetrieveSettings();
status_t _SaveSettings();
mouse_settings fSettings, fOriginalSettings;
mode_mouse fMode, fOriginalMode;
mode_focus_follows_mouse fFocusFollowsMouseMode;
mode_focus_follows_mouse fOriginalFocusFollowsMouseMode;
bool fAcceptFirstClick, fOriginalAcceptFirstClick;
BPoint fWindowPosition;
};
#endif // MOUSE_SETTINGS_H
-390
View File
@@ -1,390 +0,0 @@
/*
* Copyright 2003-2015 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
* Philippe Saint-Pierre [email protected]
*/
#include "MouseView.h"
#include <algorithm>
#include <Box.h>
#include <Button.h>
#include <Debug.h>
#include <GradientLinear.h>
#include <GradientRadial.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <PopUpMenu.h>
#include <Region.h>
#include <Shape.h>
#include <Slider.h>
#include <TextControl.h>
#include <TranslationUtils.h>
#include <TranslatorFormats.h>
#include <Window.h>
#include "MouseConstants.h"
#include "MouseSettings.h"
#include "MouseWindow.h"
static const int32 kButtonTop = 3;
static const int32 kMouseDownWidth = 72;
static const int32 kMouseDownHeight = 35;
static const int32 kOneButtonOffsets[4]
= { 0, kMouseDownWidth };
static const int32 kTwoButtonOffsets[4]
= { 0, kMouseDownWidth / 2, kMouseDownWidth };
static const int32 kThreeButtonOffsets[4]
= { 0, kMouseDownWidth / 3 + 1, kMouseDownWidth / 3 * 2, kMouseDownWidth };
static const rgb_color kButtonTextColor = { 0, 0, 0, 255 };
static const rgb_color kMouseShadowColor = { 100, 100, 100, 128 };
static const rgb_color kMouseBodyTopColor = { 0xed, 0xed, 0xed, 255 };
static const rgb_color kMouseBodyBottomColor = { 0x85, 0x85, 0x85, 255 };
static const rgb_color kMouseOutlineColor = { 0x51, 0x51, 0x51, 255 };
static const rgb_color kMouseButtonOutlineColor = { 0xa0, 0xa0, 0xa0, 255 };
static const rgb_color kButtonPressedColor = { 110, 110, 110, 110 };
static const int32*
getButtonOffsets(int32 type)
{
switch (type) {
case 1:
return kOneButtonOffsets;
case 2:
return kTwoButtonOffsets;
case 3:
default:
return kThreeButtonOffsets;
}
}
static uint32
getMappingNumber(int32 mapping)
{
switch (mapping) {
case B_PRIMARY_MOUSE_BUTTON:
return 0;
case B_SECONDARY_MOUSE_BUTTON:
return 1;
case B_TERTIARY_MOUSE_BUTTON:
return 2;
}
return 0;
}
// #pragma mark -
MouseView::MouseView(const MouseSettings &settings)
:
BView("mouse_view", B_PULSE_NEEDED | B_WILL_DRAW),
fSettings(settings),
fType(-1),
fButtons(0),
fOldButtons(0)
{
SetEventMask(B_POINTER_EVENTS, B_NO_POINTER_HISTORY);
fScaling = std::max(1.0f, be_plain_font->Size() / 12.0f);
}
MouseView::~MouseView()
{
}
void
MouseView::SetMouseType(int32 type)
{
fType = type;
Invalidate();
}
void
MouseView::MouseMapUpdated()
{
Invalidate();
}
void
MouseView::UpdateFromSettings()
{
SetMouseType(fSettings.MouseType());
}
void
MouseView::GetPreferredSize(float* _width, float* _height)
{
if (_width != NULL)
*_width = fScaling * (kMouseDownWidth + 2);
if (_height != NULL)
*_height = fScaling * 104;
}
void
MouseView::AttachedToWindow()
{
AdoptParentColors();
UpdateFromSettings();
_CreateButtonsPicture();
font_height fontHeight;
GetFontHeight(&fontHeight);
fDigitHeight = int32(ceilf(fontHeight.ascent) + ceilf(fontHeight.descent));
fDigitBaseline = int32(ceilf(fontHeight.ascent));
}
void
MouseView::MouseUp(BPoint)
{
fButtons = 0;
Invalidate(_ButtonsRect());
fOldButtons = fButtons;
}
void
MouseView::MouseDown(BPoint where)
{
BMessage *mouseMsg = Window()->CurrentMessage();
fButtons = mouseMsg->FindInt32("buttons");
int32 modifiers = mouseMsg->FindInt32("modifiers");
if (modifiers & B_CONTROL_KEY) {
if (modifiers & B_COMMAND_KEY)
fButtons = B_TERTIARY_MOUSE_BUTTON;
else
fButtons = B_SECONDARY_MOUSE_BUTTON;
}
// Get the current clipping region before requesting any updates.
// Otherwise those parts would be excluded from the region.
BRegion clipping;
GetClippingRegion(&clipping);
if (fOldButtons != fButtons) {
Invalidate(_ButtonsRect());
fOldButtons = fButtons;
}
const int32* offset = getButtonOffsets(fType);
int32 button = -1;
for (int32 i = 0; i <= fType; i++) {
if (_ButtonRect(offset, i).Contains(where)) {
button = i;
break;
}
}
if (button < 0)
return;
// We are setup to receive all mouse events, even if our window
// is not active, so make sure that we don't display the menu when
// the user clicked inside our view, but another window is on top.
if (clipping.Contains(where)) {
button = _ConvertFromVisualOrder(button);
BPopUpMenu menu("Mouse Map Menu");
BMessage message(kMsgMouseMap);
message.AddInt32("button", button);
menu.AddItem(new BMenuItem("1", new BMessage(message)));
menu.AddItem(new BMenuItem("2", new BMessage(message)));
menu.AddItem(new BMenuItem("3", new BMessage(message)));
menu.ItemAt(getMappingNumber(fSettings.Mapping(button)))
->SetMarked(true);
menu.SetTargetForItems(Window());
ConvertToScreen(&where);
menu.Go(where, true);
}
}
void
MouseView::Draw(BRect updateFrame)
{
SetDrawingMode(B_OP_ALPHA);
SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);
SetScale(fScaling * 1.8);
BShape mouseShape;
mouseShape.MoveTo(BPoint(16, 12));
// left
BPoint control[3] = { BPoint(12, 16), BPoint(8, 64), BPoint(32, 64) };
mouseShape.BezierTo(control);
// right
BPoint control2[3] = { BPoint(56, 64), BPoint(52, 16), BPoint(48, 12) };
mouseShape.BezierTo(control2);
// top
BPoint control3[3] = { BPoint(44, 8), BPoint(20, 8), BPoint(16, 12) };
mouseShape.BezierTo(control3);
mouseShape.Close();
// Draw the shadow
SetOrigin(-17 * fScaling, -11 * fScaling);
SetHighColor(kMouseShadowColor);
FillShape(&mouseShape, B_SOLID_HIGH);
// Draw the body
SetOrigin(-21 * fScaling, -14 * fScaling);
BGradientRadial bodyGradient(28, 24, 128);
bodyGradient.AddColor(kMouseBodyTopColor, 0);
bodyGradient.AddColor(kMouseBodyBottomColor, 255);
FillShape(&mouseShape, bodyGradient);
// Draw the outline
SetPenSize(1 / 1.8 / fScaling);
SetDrawingMode(B_OP_OVER);
SetHighColor(kMouseOutlineColor);
StrokeShape(&mouseShape, B_SOLID_HIGH);
// bottom button border
BShape buttonsOutline;
buttonsOutline.MoveTo(BPoint(13, 27));
BPoint control4[] = { BPoint(18, 30), BPoint(46, 30), BPoint(51, 27) };
buttonsOutline.BezierTo(control4);
SetHighColor(kMouseButtonOutlineColor);
StrokeShape(&buttonsOutline, B_SOLID_HIGH);
SetScale(1);
SetOrigin(0, 0);
// Separator between the buttons
const int32* offset = getButtonOffsets(fType);
for (int32 i = 1; i < fType; i++) {
BRect buttonRect = _ButtonRect(offset, i);
StrokeLine(buttonRect.LeftTop(), buttonRect.LeftBottom());
}
mouse_map map;
fSettings.Mapping(map);
SetDrawingMode(B_OP_OVER);
if (fButtons != 0)
ClipToPicture(&fButtonsPicture, B_ORIGIN, false);
for (int32 i = 0; i < fType; i++) {
// draw mapping number centered over the button
bool pressed = (fButtons & map.button[_ConvertFromVisualOrder(i)]) != 0;
// is button currently pressed?
if (pressed) {
SetDrawingMode(B_OP_ALPHA);
SetHighColor(kButtonPressedColor);
FillRect(_ButtonRect(offset, i));
}
BRect border(fScaling * (offset[i] + 1), fScaling * (kButtonTop + 5),
fScaling * offset[i + 1] - 1,
fScaling * (kButtonTop + kMouseDownHeight - 4));
if (i == 0)
border.left += fScaling * 5;
if (i == fType - 1)
border.right -= fScaling * 4;
char number[2] = {0};
number[0] = getMappingNumber(map.button[_ConvertFromVisualOrder(i)])
+ '1';
SetDrawingMode(B_OP_OVER);
SetHighColor(kButtonTextColor);
DrawString(number, BPoint(
border.left + (border.Width() - StringWidth(number)) / 2,
border.top + fDigitBaseline
+ (border.IntegerHeight() - fDigitHeight) / 2));
}
if (fButtons != 0)
ClipToPicture(NULL);
}
BRect
MouseView::_ButtonsRect() const
{
return BRect(0, fScaling * kButtonTop, fScaling * kMouseDownWidth,
fScaling * (kButtonTop + kMouseDownHeight));
}
BRect
MouseView::_ButtonRect(const int32* offsets, int index) const
{
return BRect(fScaling * offsets[index], fScaling * kButtonTop,
fScaling * offsets[index + 1] - 1,
fScaling * (kButtonTop + kMouseDownHeight));
}
int32
MouseView::_ConvertFromVisualOrder(int32 i)
{
if (fType < 3)
return i;
switch (i) {
case 0:
default:
return 0;
case 1:
return 2;
case 2:
return 1;
}
}
void
MouseView::_CreateButtonsPicture()
{
BeginPicture(&fButtonsPicture);
SetScale(1.8 * fScaling);
SetOrigin(-21 * fScaling, -14 * fScaling);
BShape mouseShape;
mouseShape.MoveTo(BPoint(48, 12));
// top
BPoint control3[3] = { BPoint(44, 8), BPoint(20, 8), BPoint(16, 12) };
mouseShape.BezierTo(control3);
// left
BPoint control[3] = { BPoint(12, 16), BPoint(13, 27), BPoint(13, 27) };
mouseShape.BezierTo(control);
// bottom
BPoint control4[] = { BPoint(18, 30), BPoint(46, 30), BPoint(51, 27) };
mouseShape.BezierTo(control4);
// right
BPoint control2[3] = { BPoint(51, 27), BPoint(50, 14), BPoint(48, 12) };
mouseShape.BezierTo(control2);
mouseShape.Close();
SetHighColor(255, 0, 0, 255);
FillShape(&mouseShape, B_SOLID_HIGH);
EndPicture();
SetScale(1);
}
-60
View File
@@ -1,60 +0,0 @@
/*
* Copyright 2003-2015 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
*/
#ifndef MOUSE_VIEW_H
#define MOUSE_VIEW_H
#include <Bitmap.h>
#include <Picture.h>
#include <PopUpMenu.h>
#include <View.h>
class MouseSettings;
class MouseView : public BView {
public:
MouseView(const MouseSettings& settings);
virtual ~MouseView();
void SetMouseType(int32 type);
void MouseMapUpdated();
void UpdateFromSettings();
virtual void GetPreferredSize(float* _width, float* _height);
virtual void AttachedToWindow();
virtual void MouseUp(BPoint where);
virtual void MouseDown(BPoint where);
virtual void Draw(BRect frame);
private:
BRect _ButtonsRect() const;
BRect _ButtonRect(const int32* offsets,
int index) const;
int32 _ConvertFromVisualOrder(int32 button);
void _CreateButtonsPicture();
private:
typedef BView inherited;
const MouseSettings& fSettings;
BPicture fButtonsPicture;
int32 fDigitBaseline;
int32 fDigitHeight;
float fScaling;
int32 fType;
uint32 fButtons;
uint32 fOldButtons;
};
#endif /* MOUSE_VIEW_H */
-252
View File
@@ -1,252 +0,0 @@
/*
* Copyright 2003-2014 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
* Brecht Machiels ([email protected])
*/
#include <Alert.h>
#include <Application.h>
#include <Button.h>
#include <Catalog.h>
#include <CheckBox.h>
#include <Debug.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <Menu.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <Message.h>
#include <Screen.h>
#include <SeparatorView.h>
#include <Slider.h>
#include "MouseWindow.h"
#include "MouseConstants.h"
#include "SettingsView.h"
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "MouseWindow"
MouseWindow::MouseWindow(BRect _rect)
:
BWindow(_rect, B_TRANSLATE_SYSTEM_NAME("Mouse"), B_TITLED_WINDOW,
B_NOT_RESIZABLE | B_NOT_ZOOMABLE | B_ASYNCHRONOUS_CONTROLS
| B_AUTO_UPDATE_SIZE_LIMITS)
{
// Add the main settings view
fSettingsView = new SettingsView(fSettings);
// Add the "Default" button
fDefaultsButton = new BButton(B_TRANSLATE("Defaults"),
new BMessage(kMsgDefaults));
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
// Add the "Revert" button
fRevertButton = new BButton(B_TRANSLATE("Revert"),
new BMessage(kMsgRevert));
fRevertButton->SetEnabled(false);
SetPulseRate(100000);
// we are using the pulse rate to scan pressed mouse
// buttons and draw the selected imagery
// Build the layout
BLayoutBuilder::Group<>(this, B_VERTICAL)
.AddGroup(B_HORIZONTAL)
.SetInsets(B_USE_WINDOW_SPACING, B_USE_WINDOW_SPACING,
B_USE_WINDOW_SPACING, 0)
.Add(fSettingsView)
.End()
.Add(new BSeparatorView(B_HORIZONTAL))
.AddGroup(B_HORIZONTAL)
.SetInsets(B_USE_WINDOW_SPACING, 0, B_USE_WINDOW_SPACING,
B_USE_WINDOW_SPACING)
.Add(fDefaultsButton)
.Add(fRevertButton)
.AddGlue()
.End();
// check if the window is on screen
BRect rect = BScreen().Frame();
rect.InsetBySelf(20, 20);
BPoint position = fSettings.WindowPosition();
BRect windowFrame = Frame().OffsetToSelf(position);
if (!rect.Contains(windowFrame)) {
// center window on screen as it doesn't fit on the saved position
position.x = (rect.Width() - windowFrame.Width()) / 2;
position.y = (rect.Height() - windowFrame.Height()) / 2;
if (position.x < 0)
position.x = 0;
if (position.y < 0)
position.y = 15;
}
MoveTo(position);
}
bool
MouseWindow::QuitRequested()
{
fSettings.SetWindowPosition(Frame().LeftTop());
be_app->PostMessage(B_QUIT_REQUESTED);
return true;
}
void
MouseWindow::MessageReceived(BMessage* message)
{
switch (message->what) {
case kMsgDefaults: {
// reverts to default settings
fSettings.Defaults();
fSettingsView->UpdateFromSettings();
fDefaultsButton->SetEnabled(false);
fRevertButton->SetEnabled(fSettings.IsRevertable());
break;
}
case kMsgRevert: {
// revert to last settings
fSettings.Revert();
fSettingsView->UpdateFromSettings();
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(false);
break;
}
case kMsgMouseType:
{
int32 type;
if (message->FindInt32("index", &type) == B_OK) {
fSettings.SetMouseType(++type);
fSettingsView->SetMouseType(type);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(fSettings.IsRevertable());
}
break;
}
case kMsgMouseFocusMode:
{
int32 mode;
if (message->FindInt32("mode", &mode) == B_OK) {
fSettings.SetMouseMode((mode_mouse)mode);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(fSettings.IsRevertable());
fSettingsView->fFocusFollowsMouseMenu->SetEnabled(
mode == B_FOCUS_FOLLOWS_MOUSE);
fSettingsView->fAcceptFirstClickBox->SetEnabled(
mode != B_FOCUS_FOLLOWS_MOUSE);
}
break;
}
case kMsgFollowsMouseMode:
{
int32 mode;
if (message->FindInt32("mode_focus_follows_mouse", &mode)
== B_OK) {
fSettings.SetFocusFollowsMouseMode(
(mode_focus_follows_mouse)mode);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(fSettings.IsRevertable());
}
break;
}
case kMsgAcceptFirstClick:
{
BHandler *handler;
if (message->FindPointer("source",
reinterpret_cast<void**>(&handler)) == B_OK) {
bool acceptFirstClick = false;
BCheckBox *acceptFirstClickBox =
dynamic_cast<BCheckBox*>(handler);
if (acceptFirstClickBox)
acceptFirstClick = acceptFirstClickBox->Value()
== B_CONTROL_ON;
fSettings.SetAcceptFirstClick(acceptFirstClick);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(fSettings.IsRevertable());
}
break;
}
case kMsgDoubleClickSpeed:
{
int32 value;
if (message->FindInt32("be:value", &value) == B_OK) {
// slow = 1000000, fast = 0
fSettings.SetClickSpeed(value * 1000);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(fSettings.IsRevertable());
}
break;
}
case kMsgMouseSpeed:
{
int32 value;
if (message->FindInt32("be:value", &value) == B_OK) {
// slow = 8192, fast = 524287
fSettings.SetMouseSpeed((int32)pow(2,
value * 6.0 / 1000) * 8192);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(fSettings.IsRevertable());
}
break;
}
case kMsgAccelerationFactor:
{
int32 value;
if (message->FindInt32("be:value", &value) == B_OK) {
// slow = 0, fast = 262144
fSettings.SetAccelerationFactor((int32)pow(
value * 4.0 / 1000, 2) * 16384);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(fSettings.IsRevertable());
}
break;
}
case kMsgMouseMap:
{
int32 index;
int32 button;
if (message->FindInt32("index", &index) == B_OK
&& message->FindInt32("button", &button) == B_OK) {
int32 mapping = B_PRIMARY_MOUSE_BUTTON;
switch (index) {
case 1:
mapping = B_SECONDARY_MOUSE_BUTTON;
break;
case 2:
mapping = B_TERTIARY_MOUSE_BUTTON;
break;
}
fSettings.SetMapping(button, mapping);
fDefaultsButton->SetEnabled(fSettings.IsDefaultable());
fRevertButton->SetEnabled(fSettings.IsRevertable());
fSettingsView->MouseMapUpdated();
}
break;
}
default:
BWindow::MessageReceived(message);
break;
}
}
-39
View File
@@ -1,39 +0,0 @@
/*
* Copyright 2003-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
* Brecht Machiels ([email protected])
*/
#ifndef MOUSE_WINDOW_H
#define MOUSE_WINDOW_H
#include <Box.h>
#include <Button.h>
#include <Window.h>
#include "MouseSettings.h"
class SettingsView;
class MouseWindow : public BWindow {
public:
MouseWindow(BRect rect);
virtual bool QuitRequested();
virtual void MessageReceived(BMessage *message);
private:
MouseSettings fSettings;
BButton *fDefaultsButton;
BButton *fRevertButton;
SettingsView *fSettingsView;
BBox *fSettingsBox;
};
#endif /* MOUSE_WINDOW_H */
-291
View File
@@ -1,291 +0,0 @@
/*
* Copyright 2003-2014 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
* Brecht Machiels ([email protected])
*/
#include "SettingsView.h"
#include <Bitmap.h>
#include <Box.h>
#include <Button.h>
#include <Catalog.h>
#include <Debug.h>
#include <InterfaceDefs.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <PopUpMenu.h>
#include <SeparatorView.h>
#include <Slider.h>
#include <TextControl.h>
#include <TranslationUtils.h>
#include <Window.h>
#include "MouseConstants.h"
#include "MouseSettings.h"
#include "MouseView.h"
static int32
mouse_mode_to_index(mode_mouse mode)
{
switch (mode) {
case B_NORMAL_MOUSE:
default:
return 0;
case B_CLICK_TO_FOCUS_MOUSE:
return 1;
case B_FOCUS_FOLLOWS_MOUSE:
return 2;
}
}
static int32
focus_follows_mouse_mode_to_index(mode_focus_follows_mouse mode)
{
switch (mode) {
case B_NORMAL_FOCUS_FOLLOWS_MOUSE:
default:
return 0;
case B_WARP_FOCUS_FOLLOWS_MOUSE:
return 1;
case B_INSTANT_WARP_FOCUS_FOLLOWS_MOUSE:
return 2;
}
}
// #pragma mark -
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "SettingsView"
SettingsView::SettingsView(MouseSettings& settings)
: BBox("main_view"),
fSettings(settings)
{
// Add the "Mouse Type" pop up menu
fTypeMenu = new BPopUpMenu("unknown");
fTypeMenu->AddItem(new BMenuItem(B_TRANSLATE("1-Button"),
new BMessage(kMsgMouseType)));
fTypeMenu->AddItem(new BMenuItem(B_TRANSLATE("2-Button"),
new BMessage(kMsgMouseType)));
fTypeMenu->AddItem(new BMenuItem(B_TRANSLATE("3-Button"),
new BMessage(kMsgMouseType)));
BMenuField* typeField = new BMenuField(B_TRANSLATE("Mouse type:"),
fTypeMenu);
typeField->SetAlignment(B_ALIGN_LEFT);
// Create the "Double-click speed slider...
fClickSpeedSlider = new BSlider("double_click_speed",
B_TRANSLATE("Double-click speed"), new BMessage(kMsgDoubleClickSpeed),
0, 1000, B_HORIZONTAL);
fClickSpeedSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fClickSpeedSlider->SetHashMarkCount(7);
// Create the "Mouse Speed" slider...
fMouseSpeedSlider = new BSlider("mouse_speed", B_TRANSLATE("Mouse speed"),
new BMessage(kMsgMouseSpeed), 0, 1000, B_HORIZONTAL);
fMouseSpeedSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fMouseSpeedSlider->SetHashMarkCount(7);
// Create the "Mouse Acceleration" slider...
fAccelerationSlider = new BSlider("mouse_acceleration",
B_TRANSLATE("Mouse acceleration"),
new BMessage(kMsgAccelerationFactor), 0, 1000, B_HORIZONTAL);
fAccelerationSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fAccelerationSlider->SetHashMarkCount(7);
// Mouse image...
fMouseView = new MouseView(fSettings);
// Create the "Double-click test area" text box...
const char* label = B_TRANSLATE("Double-click test area");
BTextControl* doubleClickTextControl = new BTextControl(NULL,
label, NULL);
doubleClickTextControl->SetAlignment(B_ALIGN_LEFT, B_ALIGN_CENTER);
doubleClickTextControl->SetExplicitMinSize(
BSize(StringWidth(label), B_SIZE_UNSET));
// Add the "Mouse focus mode" pop up menu
fFocusMenu = new BPopUpMenu(B_TRANSLATE("Click to focus and raise"));
const char *focusLabels[] = {B_TRANSLATE_MARK("Click to focus and raise"),
B_TRANSLATE_MARK("Click to focus"),
B_TRANSLATE_MARK("Focus follows mouse")};
const mode_mouse focusModes[] = {B_NORMAL_MOUSE, B_CLICK_TO_FOCUS_MOUSE,
B_FOCUS_FOLLOWS_MOUSE};
for (int i = 0; i < 3; i++) {
BMessage* message = new BMessage(kMsgMouseFocusMode);
message->AddInt32("mode", focusModes[i]);
fFocusMenu->AddItem(new BMenuItem(B_TRANSLATE_NOCOLLECT(focusLabels[i]),
message));
}
BMenuField* focusField = new BMenuField(B_TRANSLATE("Focus mode:"),
fFocusMenu);
focusField->SetAlignment(B_ALIGN_LEFT);
// Add the "Focus follows mouse mode" pop up menu
fFocusFollowsMouseMenu = new BPopUpMenu(B_TRANSLATE("Normal"));
const char *focusFollowsMouseLabels[] = {B_TRANSLATE_MARK("Normal"),
B_TRANSLATE_MARK("Warp"), B_TRANSLATE_MARK("Instant warp")};
const mode_focus_follows_mouse focusFollowsMouseModes[]
= {B_NORMAL_FOCUS_FOLLOWS_MOUSE, B_WARP_FOCUS_FOLLOWS_MOUSE,
B_INSTANT_WARP_FOCUS_FOLLOWS_MOUSE};
for (int i = 0; i < 3; i++) {
BMessage* message = new BMessage(kMsgFollowsMouseMode);
message->AddInt32("mode_focus_follows_mouse",
focusFollowsMouseModes[i]);
fFocusFollowsMouseMenu->AddItem(new BMenuItem(
B_TRANSLATE_NOCOLLECT(focusFollowsMouseLabels[i]), message));
}
BMenuField* focusFollowsMouseField = new BMenuField(
"Focus follows mouse mode:", fFocusFollowsMouseMenu);
focusFollowsMouseField->SetAlignment(B_ALIGN_RIGHT);
// Add the "Click-through" check box
fAcceptFirstClickBox = new BCheckBox(B_TRANSLATE("Accept first click"),
new BMessage(kMsgAcceptFirstClick));
// Build the layout
// Layout is :
// A | B
// -----
// C
BLayoutBuilder::Group<>(this, B_VERTICAL, B_USE_DEFAULT_SPACING)
// Horizontal : A|B
.AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING)
// Vertical block A: mouse type/view/test
.AddGroup(B_VERTICAL, B_USE_DEFAULT_SPACING)
.AddGroup(B_HORIZONTAL, 0)
.AddGlue()
.Add(typeField)
.AddGlue()
.End()
.AddGlue()
.AddGroup(B_HORIZONTAL, 0)
.AddGlue()
.Add(fMouseView)
.AddGlue()
.End()
.AddGlue()
.Add(doubleClickTextControl)
.End()
.Add(new BSeparatorView(B_VERTICAL))
// Vertical block B: speed settings
.AddGroup(B_VERTICAL, B_USE_DEFAULT_SPACING, 3)
.AddGroup(B_HORIZONTAL, 0)
.Add(fClickSpeedSlider)
.End()
.AddGroup(B_HORIZONTAL, 0)
.Add(fMouseSpeedSlider)
.End()
.AddGroup(B_HORIZONTAL, 0)
.Add(fAccelerationSlider)
.End()
.End()
.End()
.AddStrut(B_USE_DEFAULT_SPACING)
// Horizontal Block C: focus mode
.AddGroup(B_HORIZONTAL, B_USE_SMALL_SPACING)
.Add(focusField)
.AddGlue()
.AddGroup(B_VERTICAL, 0)
.Add(fAcceptFirstClickBox)
.End()
.End();
SetBorder(B_NO_BORDER);
}
SettingsView::~SettingsView()
{
}
void
SettingsView::AttachedToWindow()
{
UpdateFromSettings();
}
void
SettingsView::SetMouseType(int32 type)
{
fMouseView->SetMouseType(type);
}
void
SettingsView::MouseMapUpdated()
{
fMouseView->MouseMapUpdated();
}
void
SettingsView::UpdateFromSettings()
{
int32 value = int32(fSettings.ClickSpeed() / 1000);
// slow = 1000000, fast = 0
fClickSpeedSlider->SetValue(value);
value = int32((log(fSettings.MouseSpeed() / 8192.0) / log(2)) * 1000 / 6);
// slow = 8192, fast = 524287
fMouseSpeedSlider->SetValue(value);
value = int32(sqrt(fSettings.AccelerationFactor() / 16384.0) * 1000 / 4);
// slow = 0, fast = 262144
fAccelerationSlider->SetValue(value);
BMenuItem* item = fTypeMenu->ItemAt(fSettings.MouseType() - 1);
if (item != NULL)
item->SetMarked(true);
fMouseView->SetMouseType(fSettings.MouseType());
item = fFocusMenu->ItemAt(mouse_mode_to_index(fSettings.MouseMode()));
if (item != NULL)
item->SetMarked(true);
item = fFocusFollowsMouseMenu->ItemAt(
focus_follows_mouse_mode_to_index(fSettings.FocusFollowsMouseMode()));
if (item != NULL)
item->SetMarked(true);
fFocusFollowsMouseMenu->SetEnabled(fSettings.MouseMode()
== B_FOCUS_FOLLOWS_MOUSE);
fAcceptFirstClickBox->SetValue(fSettings.AcceptFirstClick()
? B_CONTROL_ON : B_CONTROL_OFF);
fAcceptFirstClickBox->SetEnabled(fSettings.MouseMode()
!= B_FOCUS_FOLLOWS_MOUSE);
}
-55
View File
@@ -1,55 +0,0 @@
/*
* Copyright 2003-2009 Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Jérôme Duval,
* Axel Dörfler ([email protected])
* Andrew McCall ([email protected])
* Brecht Machiels ([email protected])
*/
#ifndef SETTINGS_VIEW_H
#define SETTINGS_VIEW_H
#include <Box.h>
#include <Bitmap.h>
#include <Button.h>
#include <CheckBox.h>
#include <Slider.h>
#include <PopUpMenu.h>
class MouseSettings;
class MouseView;
class SettingsView : public BBox {
public:
SettingsView(MouseSettings &settings);
virtual ~SettingsView();
virtual void AttachedToWindow();
void SetMouseType(int32 type);
void MouseMapUpdated();
void UpdateFromSettings();
private:
friend class MouseWindow;
typedef BBox inherited;
const MouseSettings &fSettings;
BPopUpMenu* fTypeMenu;
BPopUpMenu* fFocusMenu;
BPopUpMenu* fFocusFollowsMouseMenu;
BCheckBox* fAcceptFirstClickBox;
MouseView* fMouseView;
BSlider* fClickSpeedSlider;
BSlider* fMouseSpeedSlider;
BSlider* fAccelerationSlider;
};
#endif /* SETTINGS_VIEW_H */
-18
View File
@@ -1,18 +0,0 @@
SubDir HAIKU_TOP src preferences touchpad ;
UsePrivateHeaders input ;
Preference Touchpad :
TouchpadPref.cpp
TouchpadPrefView.cpp
main.cpp
: be [ TargetLibsupc++ ] localestub
: Touchpad.rdef
;
DoCatalogs Touchpad :
x-vnd.Haiku-Touchpad
:
TouchpadPrefView.cpp
main.cpp
;
-246
View File
@@ -1,246 +0,0 @@
resource app_signature "application/x-vnd.Haiku-Touchpad";
resource app_name_catalog_entry "x-vnd.Haiku-Touchpad:System name:Touchpad";
resource app_flags B_SINGLE_LAUNCH;
resource app_version {
major = 1,
middle = 0,
minor = 0,
/* 0 = development 1 = alpha 2 = beta
3 = gamma 4 = golden master 5 = final */
variety = 2,
internal = 0,
short_info = "Touchpad",
long_info = "Touchpad ©2002-2009 Haiku"
};
resource vector_icon {
$"6E6369660804016E0501020006023C67322F27DFB19BC13EBF7049ECF347B011"
$"00E9ECF0FFAAB5BE0200060239FD3736EBD9BACFE23DD7074A5DFE48B6640084"
$"96A3FF86A7BE020006033A061C3A03E4BED2853ED5A04B5372461D6F00BFCBD6"
$"77D8E3EBFFAAB5BE0200060336E53E3693C0BD68493DD4084BB36248EBAC00D5"
$"E7F6B47A98AEFF96A9B90200060237DFA0368620B6CBC53825414A24904B0B5F"
$"00F3F3F3FFB8CBDB020002023CDA6E34E581B61D283E151248B8A9472070004F"
$"617106FFFFFFFFEB080A045C3B5E3C475844580A043E334F39394E27450A0422"
$"453A5153383E300606AE0B4456BFCFC6F3C096C757BEFEC68B3C52C3E0C1334E"
$"45C4A7C1675046C64BC2B306032E4456BFCFC6F3C096C757BEFEC68B3C520605"
$"EA0244563C52C3E0C1334E45C4A7C1675046C64BC2B30606BA0EC493C0805638"
$"C9A6BC8AC912BC59CA44BCBF5C3AC6FEC201C606C10BC6D2C171C550C0B00802"
$"3B364B3D080A000100000A01030206051001178422040A020101000A04020102"
$"000A030201071001178100040A070101100215820004178100040A0502030600"
$"0A06010400"
};
resource(601, "double_click_bmap") #'bits' array {
$"424D06070000000000003A000000280000000E0000001E000000010018000000"
$"0000CC060000130B0000130B00000000000000000000FFFFFFFFD8D8D8000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"00D8D8D800000000008080808080808080808080808080808080808080808080"
$"808080808080808080808080800000000000000000B8B8B8FFFFFFB8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B880808000000000000000"
$"00B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B88080800000000000000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B88080800000000000000000B8B8B8FFFFFFB8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8808080000000"
$"0000000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B87F7F7F0000000000000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B88080800000000000000000B8B8B8"
$"FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B88080"
$"800000000000000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B88080800000000000000000B8B8B8FFFFFFFFFFFFFFFF"
$"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80808000000000000000"
$"0080808080808080808080808080808080808080808080808080808080808080"
$"80808080800000000000000000B8B8B8FFFFFFB8B8B8B8B8B8C0C0C0808080FF"
$"FFFFC0C0C0B8B8B8B8B8B8B8B8B88080800000000000000000B8B8B8FFFFFFB8"
$"B8B8B8B8B8C0C0C0808080FFFFFFC0C0C0B8B8B8B8B8B8B8B8B8808080000000"
$"0000000000B8B8B8FFFFFFB8B8B8B8B8B8C0C0C0808080FFFFFFC0C0C0B8B8B8"
$"B8B8B8B8B8B88080800000000000000000B8B8B8FFFFFFFFFFFFFFFFFFFFFFFF"
$"808080FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8080800000000000000000B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8808080B8B8B8B8B8B8B8B8B8B8B8B8B8B8B88080"
$"800000000000D8D8D80000000000000000000000000000005858580000000000"
$"00000000000000000000000000D8D8D80000D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8000000000000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D80000D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D80000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D80000D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"0000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D80000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"989898D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D80000D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8989898989898989898D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D80000D8D8D8D8D8D8D8D8D8D8D8D89898989898989898989898989898"
$"98D8D8D8D8D8D8D8D8D8D8D8D8D8D8D80000D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8989898D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D80000D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8989898989898989898D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D80000D8D8D8D8D8D8D8D8D8D8D8D898989898989898989898"
$"9898989898D8D8D8D8D8D8D8D8D8D8D8D8D8D8D80000D8D8D8D8D8D8D8D8D898"
$"9898989898989898989898989898989898989898D8D8D8D8D8D8D8D8D8D8D8D8"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"000000000000"
};
resource(602, "speed_bmap") #'bits' array {
$"424DE8080000000000003A000000280000001900000016000000010018000000"
$"0000AE080000130B0000130B00000000000000000000FFFFFFFFD8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D800D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D800000000000000000000000000000000000000000000"
$"0000000000000000000000000000D8D8D800D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D800000080808080808080808080"
$"808080808080808080808080808080808080808080808080808000000000D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D800"
$"0000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B880808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFF"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B88080800000"
$"0000D8D8D8D8D8D8D8D8D8989898D8D8D8989898989898989898989898D8D8D8"
$"D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8"
$"B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B880"
$"808000000000989898D8D8D89898989898989898989898989898989898989898"
$"98D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B87F7F7F00000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B880808000000000D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D800"
$"0000B8B8B8FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"
$"FFFFFF80808000000000D8D8D8D8D8D8D8D8D8989898D8D8D898989898989898"
$"9898989898D8D8D8D8D8D8000000808080808080808080808080808080808080"
$"80808080808080808080808080808080808000000000D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFF"
$"B8B8B8B8B8B8C0C0C0808080FFFFFFC0C0C0B8B8B8B8B8B8B8B8B88080800000"
$"0000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8C0C0C0808080FFFFFFC0C0C0B8B8"
$"B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8C0C0"
$"C0808080FFFFFFC0C0C0B8B8B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8"
$"B8FFFFFFFFFFFFFFFFFFFFFFFF808080FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80"
$"808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8000000B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8808080B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D800000000000000000000"
$"0000000000585858000000000000000000000000000000000000D8D8D800D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000000000000000D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D800D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D800D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D800000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000000000000000"
};
resource(603, "acceleration_bmap") #'bits' array {
$"424D83080000000000003A000000280000001900000015000000010018000000"
$"000049080000130B0000130B00000000F8410000F841FFFFFFFFD8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D80000"
$"0000000000000000000000000000000000000000000000000000000000000000"
$"0000D8D8D800D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D800000080808080808080808080808080808080808080808080"
$"808080808080808080808080808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B880808000000000D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D800"
$"0000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B880808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8D8D8D898"
$"9898D8D8D8989898989898989898989898D8D8D8D8D8D8000000B8B8B8FFFFFF"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B88080800000"
$"0000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B87F7F7F00000000989898D8D8D8"
$"989898989898989898989898989898989898989898D8D8D8D8D8D8000000B8B8"
$"B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B880"
$"808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8B8B8B8B8B8B8B8B8B8B8"
$"B8B8B8B8B8B8B8B8B8B8B87F7F7F00000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFFFFFFFFF"
$"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80808000000000D8D8"
$"D8D8D8D8D8D8D8989898D8D8D8989898989898989898989898D8D8D8D8D8D800"
$"0000808080808080808080808080808080808080808080808080808080808080"
$"80808080808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8C0C0C0808080"
$"FFFFFFC0C0C0B8B8B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFF"
$"B8B8B8B8B8B8C0C0C0808080FFFFFFC0C0C0B8B8B8B8B8B8B8B8B88080800000"
$"0000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8000000B8B8B8FFFFFFB8B8B8B8B8B8C0C0C0808080FFFFFFC0C0C0B8B8"
$"B8B8B8B8B8B8B880808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8B8FFFFFFFFFFFFFFFFFFFFFF"
$"FF808080FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80808000000000D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000B8B8"
$"B8B8B8B8B8B8B8B8B8B8B8B8B8808080B8B8B8B8B8B8B8B8B8B8B8B8B8B8B880"
$"808000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D800000000000000000000000000000058585800000000"
$"0000000000000000000000000000D8D8D800D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8000000000000000000D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D800D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D800D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8000000"
$"D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D8D800000090413D3D3DFF0000"
$"80420000984100008042000008423D0000FF0000804200000C42000080420000"
$"4842003D00FF0000804200004C42000080420000844200003DFF000082420000"
$"004000008242000090413E3E3EFF000082420000984100008242000008423E00"
$"00FF0000824200000C420000824200004842003E00FF0000824200004C420000"
$"82420000844200003EFF000084420000004000008442000090413F3F3FFF0000"
$"84420000984100008442000008423F0000FF0000844200000C42000084420000"
$"4842003F00FF0000844200004C42000084420000844200003FFF000086420000"
$"00400000864200009041404040FF000086420000984100008642000008424000"
$"00FF0000864200000C420000864200004842004000FF0000864200004C420000"
$"864200008442000040FF00008842000000400000884200009041414141FF0000"
$"8842000098410000884200000842410000FF0000884200000C42000088420000"
$"4842004100FF0000884200004C420000884200008442000041FF00008A420000"
$"004000008A4200009041424242FF00008A420000984100008A42000008424200"
$"00FF00008A4200000C4200008A4200004842004200FF00008A4200004C420000"
$"8A4200008442000042FF00008C420000004000008C4200009041434343FF0000"
$"8C420000984100008C4200000842430000FF00008C4200000C4200008C420000"
$"484200"
};
-186
View File
@@ -1,186 +0,0 @@
/*
* Copyright 2008-2010, Haiku, Inc.
* Distributed under the terms of the MIT License.
*
* Authors:
* Clemens Zeidler ([email protected])
*/
#include "TouchpadPref.h"
#include <List.h>
#include <FindDirectory.h>
#include <File.h>
#include <String.h>
#include <keyboard_mouse_driver.h>
TouchpadPref::TouchpadPref()
{
fConnected = false;
// default center position
fWindowPosition.x = -1;
fWindowPosition.y = -1;
ConnectToTouchPad();
if (LoadSettings() != B_OK)
Defaults();
fStartSettings = fSettings;
}
TouchpadPref::~TouchpadPref()
{
if (fConnected)
delete fTouchPad;
SaveSettings();
}
void
TouchpadPref::Revert()
{
fSettings = fStartSettings;
}
status_t
TouchpadPref::UpdateSettings()
{
if (!fConnected)
return B_ERROR;
LOG("UpdateSettings of device %s\n", fTouchPad->Name());
BMessage msg;
msg.AddBool("scroll_twofinger", fSettings.scroll_twofinger);
msg.AddBool("scroll_twofinger_horizontal",
fSettings.scroll_twofinger_horizontal);
msg.AddFloat("scroll_rightrange", fSettings.scroll_rightrange);
msg.AddFloat("scroll_bottomrange", fSettings.scroll_bottomrange);
msg.AddInt16("scroll_xstepsize", fSettings.scroll_xstepsize);
msg.AddInt16("scroll_ystepsize", fSettings.scroll_ystepsize);
msg.AddInt8("scroll_acceleration", fSettings.scroll_acceleration);
msg.AddInt8("tapgesture_sensibility", fSettings.tapgesture_sensibility);
return fTouchPad->Control(MS_SET_TOUCHPAD_SETTINGS, &msg);
}
void
TouchpadPref::Defaults()
{
fSettings = kDefaultTouchpadSettings;
}
status_t
TouchpadPref::GetSettingsPath(BPath &path)
{
status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
if (status < B_OK)
return status;
return path.Append(TOUCHPAD_SETTINGS_FILE);
}
status_t
TouchpadPref::LoadSettings()
{
BPath path;
status_t status = GetSettingsPath(path);
if (status != B_OK)
return status;
BFile settingsFile(path.Path(), B_READ_ONLY);
status = settingsFile.InitCheck();
if (status != B_OK)
return status;
if (settingsFile.Read(&fSettings, sizeof(touchpad_settings))
!= sizeof(touchpad_settings)) {
LOG("failed to load settings\n");
return B_ERROR;
}
if (settingsFile.Read(&fWindowPosition, sizeof(BPoint))
!= sizeof(BPoint)) {
LOG("failed to load settings\n");
return B_ERROR;
}
return B_OK;
}
status_t
TouchpadPref::SaveSettings()
{
BPath path;
status_t status = GetSettingsPath(path);
if (status != B_OK)
return status;
BFile settingsFile(path.Path(), B_READ_WRITE | B_CREATE_FILE);
status = settingsFile.InitCheck();
if (status != B_OK)
return status;
if (settingsFile.Write(&fSettings, sizeof(touchpad_settings))
!= sizeof(touchpad_settings)) {
LOG("can't save settings\n");
return B_ERROR;
}
if (settingsFile.Write(&fWindowPosition, sizeof(BPoint))
!= sizeof(BPoint)) {
LOG("can't save window position\n");
return B_ERROR;
}
return B_OK;
}
status_t
TouchpadPref::ConnectToTouchPad()
{
BList devList;
status_t status = get_input_devices(&devList);
if (status != B_OK)
return status;
int32 i = 0;
while (true) {
BInputDevice* dev = (BInputDevice*)devList.ItemAt(i);
if (dev == NULL)
break;
i++;
LOG("input device %s\n", dev->Name());
BString name = dev->Name();
if (name.FindFirst("Touchpad") >= 0
&& dev->Type() == B_POINTING_DEVICE
&& !fConnected) {
fConnected = true;
fTouchPad = dev;
// Don't bail out here, since we need to delete the other devices
// yet.
} else {
delete dev;
}
}
if (fConnected)
return B_OK;
LOG("touchpad input device NOT found\n");
return B_ENTRY_NOT_FOUND;
}
-60
View File
@@ -1,60 +0,0 @@
/*
* Copyright 2008-2009, Haiku, Inc.
* Distributed under the terms of the MIT License.
*
* Authors:
* Clemens Zeidler ([email protected])
*/
#ifndef TOUCHPAD_PREF_H
#define TOUCHPAD_PREF_H
#include <Debug.h>
#include "touchpad_settings.h"
#include <Input.h>
#include <Path.h>
#if DEBUG
# define LOG(text...) PRINT((text))
#else
# define LOG(text...)
#endif
class TouchpadPref {
public:
TouchpadPref();
~TouchpadPref();
void Revert();
void Defaults();
BPoint WindowPosition()
{ return fWindowPosition; }
void SetWindowPosition(BPoint position)
{ fWindowPosition = position; }
touchpad_settings& Settings()
{ return fSettings; }
bool IsTouchpadConnected()
{ return fConnected; }
status_t UpdateSettings();
private:
status_t GetSettingsPath(BPath& path);
status_t LoadSettings();
status_t SaveSettings();
status_t ConnectToTouchPad();
bool fConnected;
BInputDevice* fTouchPad;
touchpad_settings fSettings;
touchpad_settings fStartSettings;
BPoint fWindowPosition;
};
#endif // TOUCHPAD_PREF_H
@@ -1,511 +0,0 @@
/*
* Copyright 2008-2014 Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* John Scipione, [email protected]
* Clemens Zeidler, [email protected]
*/
#include "TouchpadPrefView.h"
#include <stdio.h>
#include <Alert.h>
#include <Box.h>
#include <Catalog.h>
#include <CheckBox.h>
#include <ControlLook.h>
#include <File.h>
#include <FindDirectory.h>
#include <Input.h>
#include <LayoutBuilder.h>
#include <Locale.h>
#include <MenuField.h>
#include <MenuItem.h>
#include <Message.h>
#include <Path.h>
#include <Screen.h>
#include <SpaceLayoutItem.h>
#include <Window.h>
#include <keyboard_mouse_driver.h>
const uint32 SCROLL_X_DRAG = 'sxdr';
const uint32 SCROLL_Y_DRAG = 'sydr';
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "TouchpadPrefView"
TouchpadView::TouchpadView(BRect frame)
:
BView(frame, "TouchpadView", B_FOLLOW_NONE, B_WILL_DRAW)
{
fXTracking = false;
fYTracking = false;
fOffScreenView = NULL;
fOffScreenBitmap = NULL;
fPrefRect = frame;
fPadRect = fPrefRect;
fPadRect.InsetBy(10, 10);
fXScrollRange = fPadRect.Width();
fYScrollRange = fPadRect.Height();
}
TouchpadView::~TouchpadView()
{
delete fOffScreenBitmap;
}
void
TouchpadView::Draw(BRect updateRect)
{
DrawSliders();
}
void
TouchpadView::MouseDown(BPoint point)
{
if (fXScrollDragZone.Contains(point)) {
fXTracking = true;
fOldXScrollRange = fXScrollRange;
SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
}
if (fYScrollDragZone.Contains(point)) {
fYTracking = true;
fOldYScrollRange = fYScrollRange;
SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
}
}
void
TouchpadView::MouseUp(BPoint point)
{
if (!fXTracking && !fYTracking)
return;
fXTracking = false;
fYTracking = false;
const float kSoftScrollLimit = 0.7;
int32 result = 0;
if (GetRightScrollRatio() > kSoftScrollLimit
|| GetBottomScrollRatio() > kSoftScrollLimit) {
BAlert* alert = new BAlert(B_TRANSLATE("Please confirm"),
B_TRANSLATE("The new scroll area is very large and may impede "
"normal mouse operation. Do you really want to change it?"),
B_TRANSLATE("OK"), B_TRANSLATE("Cancel"),
NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT);
alert->SetShortcut(1, B_ESCAPE);
result = alert->Go();
}
if (result == 0) {
BMessage msg(SCROLL_AREA_CHANGED);
Invoke(&msg);
} else {
if (GetRightScrollRatio() > kSoftScrollLimit)
fXScrollRange = fOldXScrollRange;
if (GetBottomScrollRatio() > kSoftScrollLimit)
fYScrollRange = fOldYScrollRange;
DrawSliders();
}
}
void
TouchpadView::AttachedToWindow()
{
if (!fOffScreenView)
fOffScreenView = new BView(Bounds(), "", B_FOLLOW_ALL, B_WILL_DRAW);
if (!fOffScreenBitmap) {
fOffScreenBitmap = new BBitmap(Bounds(), B_CMAP8, true, false);
if (fOffScreenBitmap && fOffScreenView)
fOffScreenBitmap->AddChild(fOffScreenView);
}
}
void
TouchpadView::SetValues(float rightRange, float bottomRange)
{
fXScrollRange = fPadRect.Width() * (1 - rightRange);
fYScrollRange = fPadRect.Height() * (1 - bottomRange);
Invalidate();
}
void
TouchpadView::GetPreferredSize(float* width, float* height)
{
if (width != NULL)
*width = fPrefRect.Width();
if (height != NULL)
*height = fPrefRect.Height();
}
void
TouchpadView::MouseMoved(BPoint point, uint32 transit, const BMessage* message)
{
if (fXTracking) {
if (point.x > fPadRect.right)
fXScrollRange = fPadRect.Width();
else if (point.x < fPadRect.left)
fXScrollRange = 0;
else
fXScrollRange = point.x - fPadRect.left;
DrawSliders();
}
if (fYTracking) {
if (point.y > fPadRect.bottom)
fYScrollRange = fPadRect.Height();
else if (point.y < fPadRect.top)
fYScrollRange = 0;
else
fYScrollRange = point.y - fPadRect.top;
DrawSliders();
}
}
void
TouchpadView::DrawSliders()
{
BView* view = fOffScreenView != NULL ? fOffScreenView : this;
if (!LockLooper())
return;
if (fOffScreenBitmap->Lock()) {
view->SetHighColor(ui_color(B_PANEL_BACKGROUND_COLOR));
view->FillRect(Bounds());
view->SetHighColor(100, 100, 100);
view->FillRoundRect(fPadRect, 4, 4);
int32 dragSize = 3; // half drag size
// scroll areas
view->SetHighColor(145, 100, 100);
BRect rightRect(fPadRect.left + fXScrollRange, fPadRect.top,
fPadRect.right, fPadRect.bottom);
view->FillRoundRect(rightRect, 4, 4);
BRect bottomRect(fPadRect.left, fPadRect.top + fYScrollRange,
fPadRect.right, fPadRect.bottom);
view->FillRoundRect(bottomRect, 4, 4);
// Stroke Rect
view->SetHighColor(100, 100, 100);
view->SetPenSize(2);
view->StrokeRoundRect(fPadRect, 4, 4);
// x scroll range line
view->SetHighColor(200, 0, 0);
view->StrokeLine(BPoint(fPadRect.left + fXScrollRange, fPadRect.top),
BPoint(fPadRect.left + fXScrollRange, fPadRect.bottom));
fXScrollDragZone = BRect(fPadRect.left + fXScrollRange - dragSize,
fPadRect.top - dragSize, fPadRect.left + fXScrollRange + dragSize,
fPadRect.bottom + dragSize);
fXScrollDragZone1 = BRect(fPadRect.left + fXScrollRange - dragSize,
fPadRect.top - dragSize, fPadRect.left + fXScrollRange + dragSize,
fPadRect.top + dragSize);
view->FillRect(fXScrollDragZone1);
fXScrollDragZone2 = BRect(fPadRect.left + fXScrollRange - dragSize,
fPadRect.bottom - dragSize,
fPadRect.left + fXScrollRange + dragSize,
fPadRect.bottom + dragSize);
view->FillRect(fXScrollDragZone2);
// y scroll range line
view->StrokeLine(BPoint(fPadRect.left, fPadRect.top + fYScrollRange),
BPoint(fPadRect.right, fPadRect.top + fYScrollRange));
fYScrollDragZone = BRect(fPadRect.left - dragSize,
fPadRect.top + fYScrollRange - dragSize,
fPadRect.right + dragSize,
fPadRect.top + fYScrollRange + dragSize);
fYScrollDragZone1 = BRect(fPadRect.left - dragSize,
fPadRect.top + fYScrollRange - dragSize, fPadRect.left + dragSize,
fPadRect.top + fYScrollRange + dragSize);
view->FillRect(fYScrollDragZone1);
fYScrollDragZone2 = BRect(fPadRect.right - dragSize,
fPadRect.top + fYScrollRange - dragSize, fPadRect.right + dragSize,
fPadRect.top + fYScrollRange + dragSize);
view->FillRect(fYScrollDragZone2);
view->Sync();
fOffScreenBitmap->Unlock();
DrawBitmap(fOffScreenBitmap, B_ORIGIN);
}
UnlockLooper();
}
// #pragma mark - TouchpadPrefView
TouchpadPrefView::TouchpadPrefView()
:
BGroupView()
{
SetupView();
// set view values
SetValues(&fTouchpadPref.Settings());
if (fTouchpadPref.IsTouchpadConnected() == false) {
DisablePref();
fShowWarning->SetText(B_TRANSLATE("No touchpad found, the settings "
"will have no effect."));
}
else
fShowWarning->Hide();
}
TouchpadPrefView::~TouchpadPrefView()
{
}
void
TouchpadPrefView::MessageReceived(BMessage* message)
{
touchpad_settings& settings = fTouchpadPref.Settings();
switch (message->what) {
case SCROLL_AREA_CHANGED:
settings.scroll_rightrange = fTouchpadView->GetRightScrollRatio();
settings.scroll_bottomrange = fTouchpadView->GetBottomScrollRatio();
fRevertButton->SetEnabled(true);
fTouchpadPref.UpdateSettings();
break;
case SCROLL_CONTROL_CHANGED:
settings.scroll_twofinger = fTwoFingerBox->Value() == B_CONTROL_ON;
settings.scroll_twofinger_horizontal
= fTwoFingerHorizontalBox->Value() == B_CONTROL_ON;
settings.scroll_acceleration = fScrollAccelSlider->Value();
settings.scroll_xstepsize = (20 - fScrollStepXSlider->Value()) * 3;
settings.scroll_ystepsize = (20 - fScrollStepYSlider->Value()) * 3;
fRevertButton->SetEnabled(true);
fTwoFingerHorizontalBox->SetEnabled(settings.scroll_twofinger);
fTouchpadPref.UpdateSettings();
break;
case TAP_CONTROL_CHANGED:
settings.tapgesture_sensibility = fTapSlider->Value();
fRevertButton->SetEnabled(true);
fTouchpadPref.UpdateSettings();
break;
case DEFAULT_SETTINGS:
fTouchpadPref.Defaults();
fRevertButton->SetEnabled(true);
fTouchpadPref.UpdateSettings();
SetValues(&settings);
break;
case REVERT_SETTINGS:
fTouchpadPref.Revert();
fTouchpadPref.UpdateSettings();
fRevertButton->SetEnabled(false);
SetValues(&settings);
break;
default:
BView::MessageReceived(message);
}
}
void
TouchpadPrefView::AttachedToWindow()
{
fTouchpadView->SetTarget(this);
fTwoFingerBox->SetTarget(this);
fTwoFingerHorizontalBox->SetTarget(this);
fScrollStepXSlider->SetTarget(this);
fScrollStepYSlider->SetTarget(this);
fScrollAccelSlider->SetTarget(this);
fTapSlider->SetTarget(this);
fDefaultButton->SetTarget(this);
fRevertButton->SetTarget(this);
BSize size = PreferredSize();
Window()->ResizeTo(size.width, size.height);
BPoint position = fTouchpadPref.WindowPosition();
// center window on screen if it had a bad position
if (position.x < 0 && position.y < 0)
Window()->CenterOnScreen();
else
Window()->MoveTo(position);
}
void
TouchpadPrefView::DetachedFromWindow()
{
fTouchpadPref.SetWindowPosition(Window()->Frame().LeftTop());
}
void
TouchpadPrefView::SetupView()
{
SetLayout(new BGroupLayout(B_VERTICAL));
BBox* scrollBox = new BBox("Touchpad");
scrollBox->SetLabel(B_TRANSLATE("Scrolling"));
fTouchpadView = new TouchpadView(BRect(0, 0, 130, 120));
fTouchpadView->SetExplicitMaxSize(BSize(130, 120));
// Create the "Mouse Speed" slider...
fScrollAccelSlider = new BSlider("scroll_accel",
B_TRANSLATE("Acceleration"),
new BMessage(SCROLL_CONTROL_CHANGED), 0, 20, B_HORIZONTAL);
fScrollAccelSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fScrollAccelSlider->SetHashMarkCount(7);
fScrollAccelSlider->SetLimitLabels(B_TRANSLATE("Slow"),
B_TRANSLATE("Fast"));
fScrollAccelSlider->SetExplicitMinSize(BSize(150, B_SIZE_UNSET));
fScrollStepXSlider = new BSlider("scroll_stepX",
B_TRANSLATE("Horizontal"),
new BMessage(SCROLL_CONTROL_CHANGED),
0, 20, B_HORIZONTAL);
fScrollStepXSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fScrollStepXSlider->SetHashMarkCount(7);
fScrollStepXSlider->SetLimitLabels(B_TRANSLATE("Slow"),
B_TRANSLATE("Fast"));
fScrollStepYSlider = new BSlider("scroll_stepY",
B_TRANSLATE("Vertical"),
new BMessage(SCROLL_CONTROL_CHANGED), 0, 20, B_HORIZONTAL);
fScrollStepYSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fScrollStepYSlider->SetHashMarkCount(7);
fScrollStepYSlider->SetLimitLabels(B_TRANSLATE("Slow"),
B_TRANSLATE("Fast"));
fTwoFingerBox = new BCheckBox(B_TRANSLATE("Two finger scrolling"),
new BMessage(SCROLL_CONTROL_CHANGED));
fTwoFingerHorizontalBox = new BCheckBox(
B_TRANSLATE("Horizontal scrolling"),
new BMessage(SCROLL_CONTROL_CHANGED));
float spacing = be_control_look->DefaultItemSpacing();
BView* scrollPrefLeftLayout
= BLayoutBuilder::Group<>(B_VERTICAL, 0)
.Add(fTouchpadView)
.AddStrut(spacing)
.Add(fTwoFingerBox)
.AddGroup(B_HORIZONTAL, 0)
.AddStrut(spacing * 2)
.Add(fTwoFingerHorizontalBox)
.End()
.AddGlue()
.View();
BGroupView* scrollPrefRightLayout = new BGroupView(B_VERTICAL);
scrollPrefRightLayout->AddChild(fScrollAccelSlider);
scrollPrefRightLayout->AddChild(fScrollStepXSlider);
scrollPrefRightLayout->AddChild(fScrollStepYSlider);
BGroupLayout* scrollPrefLayout = new BGroupLayout(B_HORIZONTAL);
scrollPrefLayout->SetSpacing(spacing);
scrollPrefLayout->SetInsets(spacing,
scrollBox->TopBorderOffset() * 2 + spacing, spacing, spacing);
scrollBox->SetLayout(scrollPrefLayout);
scrollPrefLayout->AddView(scrollPrefLeftLayout);
scrollPrefLayout->AddItem(BSpaceLayoutItem::CreateVerticalStrut(spacing
* 1.5));
scrollPrefLayout->AddView(scrollPrefRightLayout);
BBox* tapBox = new BBox("tapbox");
tapBox->SetLabel(B_TRANSLATE("Tapping"));
BGroupLayout* tapPrefLayout = new BGroupLayout(B_HORIZONTAL);
tapPrefLayout->SetInsets(spacing, tapBox->TopBorderOffset() * 2 + spacing,
spacing, spacing);
tapBox->SetLayout(tapPrefLayout);
fTapSlider = new BSlider("tap_sens", B_TRANSLATE("Sensitivity"),
new BMessage(TAP_CONTROL_CHANGED), 0, spacing * 2, B_HORIZONTAL);
fTapSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
fTapSlider->SetHashMarkCount(7);
fTapSlider->SetLimitLabels(B_TRANSLATE("Off"), B_TRANSLATE("High"));
tapPrefLayout->AddView(fTapSlider);
fDefaultButton = new BButton(B_TRANSLATE("Defaults"),
new BMessage(DEFAULT_SETTINGS));
fRevertButton = new BButton(B_TRANSLATE("Revert"),
new BMessage(REVERT_SETTINGS));
fRevertButton->SetEnabled(false);
fShowWarning = new BStringView("warning", "");
BLayoutBuilder::Group<>(this, B_VERTICAL)
.SetInsets(B_USE_WINDOW_SPACING)
.Add(fShowWarning)
.Add(scrollBox)
.Add(tapBox)
.AddGroup(B_HORIZONTAL)
.Add(fDefaultButton)
.Add(fRevertButton)
.AddGlue()
.End()
.End();
}
void
TouchpadPrefView::SetValues(touchpad_settings* settings)
{
fTouchpadView->SetValues(settings->scroll_rightrange,
settings->scroll_bottomrange);
fTwoFingerBox->SetValue(settings->scroll_twofinger
? B_CONTROL_ON : B_CONTROL_OFF);
fTwoFingerHorizontalBox->SetValue(settings->scroll_twofinger_horizontal
? B_CONTROL_ON : B_CONTROL_OFF);
fTwoFingerHorizontalBox->SetEnabled(settings->scroll_twofinger);
fScrollStepXSlider->SetValue(20 - settings->scroll_xstepsize / 2);
fScrollStepYSlider->SetValue(20 - settings->scroll_ystepsize / 2);
fScrollAccelSlider->SetValue(settings->scroll_acceleration);
fTapSlider->SetValue(settings->tapgesture_sensibility);
}
void
TouchpadPrefView::DisablePref()
{
fTwoFingerBox->SetEnabled(false);
fTwoFingerHorizontalBox->SetEnabled(false);
fRevertButton->SetEnabled(false);
fDefaultButton->SetEnabled(false);
fTapSlider->SetEnabled(false);
fScrollAccelSlider->SetEnabled(false);
fScrollStepXSlider->SetEnabled(false);
fScrollStepYSlider->SetEnabled(false);
}
-112
View File
@@ -1,112 +0,0 @@
/*
* Copyright 2008-2013 Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* John Scipione, [email protected]
* Clemens Zeidler, [email protected]
*/
#ifndef TOUCHPAD_PREF_VIEW_H
#define TOUCHPAD_PREF_VIEW_H
#include <Bitmap.h>
#include <Button.h>
#include <CheckBox.h>
#include <Invoker.h>
#include <Slider.h>
#include <View.h>
#include <GroupView.h>
#include <StringView.h>
#include "TouchpadPref.h"
#include "touchpad_settings.h"
#include <Debug.h>
#if DEBUG
# define LOG(text...) PRINT((text))
#else
# define LOG(text...)
#endif
const uint SCROLL_AREA_CHANGED = '&sac';
const uint SCROLL_CONTROL_CHANGED = '&scc';
const uint TAP_CONTROL_CHANGED = '&tcc';
const uint DEFAULT_SETTINGS = '&dse';
const uint REVERT_SETTINGS = '&rse';
//! Shows a touchpad
class TouchpadView : public BView, public BInvoker {
public:
TouchpadView(BRect frame);
virtual ~TouchpadView();
virtual void Draw(BRect updateRect);
virtual void MouseDown(BPoint point);
virtual void MouseUp(BPoint point);
virtual void MouseMoved(BPoint point, uint32 transit,
const BMessage* dragMessage);
virtual void AttachedToWindow();
virtual void GetPreferredSize(float* width, float* height);
void SetValues(float rightRange, float bottomRange);
float GetRightScrollRatio()
{ return 1 - fXScrollRange / fPadRect.Width(); }
float GetBottomScrollRatio()
{ return 1
- fYScrollRange / fPadRect.Height(); }
private:
virtual void DrawSliders();
BRect fPrefRect;
BRect fPadRect;
BRect fXScrollDragZone;
BRect fXScrollDragZone1;
BRect fXScrollDragZone2;
float fXScrollRange;
float fOldXScrollRange;
BRect fYScrollDragZone;
BRect fYScrollDragZone1;
BRect fYScrollDragZone2;
float fYScrollRange;
float fOldYScrollRange;
bool fXTracking;
bool fYTracking;
BView* fOffScreenView;
BBitmap* fOffScreenBitmap;
};
class TouchpadPrefView : public BGroupView {
public:
TouchpadPrefView();
virtual ~TouchpadPrefView();
virtual void MessageReceived(BMessage* message);
virtual void AttachedToWindow();
virtual void DetachedFromWindow();
void SetupView();
void SetValues(touchpad_settings *settings);
private:
void DisablePref();
TouchpadView* fTouchpadView;
BCheckBox* fTwoFingerBox;
BCheckBox* fTwoFingerHorizontalBox;
BSlider* fScrollStepXSlider;
BSlider* fScrollStepYSlider;
BSlider* fScrollAccelSlider;
BSlider* fTapSlider;
BButton* fDefaultButton;
BButton* fRevertButton;
BStringView* fShowWarning;
TouchpadPref fTouchpadPref;
};
#endif // TOUCHPAD_PREF_VIEW_H
-63
View File
@@ -1,63 +0,0 @@
/*
* Copyright 2008-2009, Haiku, Inc.
* Distributed under the terms of the MIT License.
*
* Authors:
* Clemens Zeidler ([email protected])
*/
#include <Application.h>
#include <Window.h>
#include <Catalog.h>
#include <GroupLayout.h>
#include <GroupLayoutBuilder.h>
#include <Locale.h>
#include "TouchpadPrefView.h"
class TouchpadPrefWindow : public BWindow {
public:
TouchpadPrefWindow(BRect frame, const char* title, window_type type,
uint32 flags)
:
BWindow(frame, title, type, flags)
{
}
virtual bool QuitRequested()
{
be_app->PostMessage(B_QUIT_REQUESTED);
return true;
}
};
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "TouchpadMain"
int
main(int argc, char* argv[])
{
BApplication* app = new BApplication("application/x-vnd.Haiku-Touchpad");
TouchpadPrefWindow* window = new TouchpadPrefWindow(BRect(50, 50, 450, 350),
B_TRANSLATE_SYSTEM_NAME("Touchpad"), B_TITLED_WINDOW,
B_NOT_RESIZABLE | B_NOT_ZOOMABLE
| B_ASYNCHRONOUS_CONTROLS | B_AUTO_UPDATE_SIZE_LIMITS);
window->SetLayout(new BGroupLayout(B_HORIZONTAL));
window->AddChild(BGroupLayoutBuilder(B_VERTICAL, 10)
.Add(new TouchpadPrefView())
.End()
.SetInsets(5, 5, 5, 5)
);
window->Show();
app->Run();
delete app;
return 0;
}