rimedio per una trackball senza rotella di scorrimento?

Sto pensando di acquistare una trackball e la mia opzione è il marmo Trackman di Logitech. Ma poi ho scoperto che non esiste una rotella di scorrimento. Come lo affronti? Voglio assolutamente comprare una trackball con rotellina di scorrimento? Scorro molto usando Facebook.

Non voglio fare clic con il mio indice e il medio, quindi alcuni mouse trackball non funzioneranno per me, come la Trackman Wheel.

Se sei su Windows, suggerirei di provare AutoHotKey, altri utenti hanno già affrontato lo scrolling con il mouse di marmo (ho usato lo script in fondo):

http://www.autohotkey.com/board/topic/4677-wheel-button-emulation-script/

La soluzione di Logitech fornita con i loro driver è strana: fai clic una volta per abilitare lo scorrimento in 4 direzioni e fai di nuovo clic per disabilitarla. Non puoi tenere premuto e scorrere, ed è quello che stavo cercando. Ho finito per disinstallare il loro software.

Ho la stessa trackball e la soluzione è molto elegante: quando si fa clic su un pulsante scelto, la palla stessa diventa una rotella di scorrimento. Ho scelto il grosso pulsante destro che premo con il mignolo.

È molto comodo e ci vogliono solo pochi giorni per abituarsi.

Considera rapidamente che qualsiasi rotellina di scorrimento (su un mouse o una trackball) è qualcosa di inutilizzabile. Fidati di me, ne vale la pena ;-)

vantaggi:

• Scorrimento 2D anziché 1D
• scorrimento più rapido e preciso di una ruota
• più comodo per lo scorrimento lungo (grazie all'inerzia della palla). Perfetto per il tuo esempio di Facebook.

Non posso più vivere senza di essa.

Configurarlo con qualsiasi SO Linux non è difficile. Richiede solo di creare un file /etc/X11/xorg.conf (vedi la mia configurazione qui: Configura una trackball sotto Linux senza modificare Xorg.conf )

Maggiori dettagli sono disponibili qui: https://help.ubuntu.com/community/Logitech_Marblemouse_USB

Su Windows, non ho esperienza ma penso che uno strumento di configurazione sia fornito con la trackball.

Potresti provare la rotellina di scorrimento del mouse in marmo, sviluppata appositamente per quel mouse:

Marble Mouse Scroll Wheel, o semplicemente Marble Scroll, è un piccolo programma progettato per simulare una rotellina di scorrimento su qualsiasi trackball o mouse senza una. È stato progettato appositamente per Logitech Marble Mouse ma può funzionare con qualsiasi mouse o trackball standard. È progettato per Windows 2000 e versioni successive.

Marble Scroll sostituisce le funzioni Autoscroll e Universal Scroll di Logitech; né emulano correttamente una vera rotella di scorrimento ed entrambi hanno limiti e difetti.

Marble Scroll funziona con qualsiasi mouse o trackball e non richiede l'installazione dei driver SetPoint o MouseWare di Logitech.

Caratteristiche

• Aggiungi una rotellina di scorrimento a qualsiasi mouse con più di due pulsanti
• Compatibilità con la maggior parte delle applicazioni che supportano una rotellina di scorrimento (per qualsiasi tipo di input)
• Accelerazione regolabile
• Distanza di scorrimento regolabile (per "passo" - vedi sotto)
• Scorrimento a gradini per simulare una vera rotellina del mouse
• Commutatore rapido per modalità sinistra / destra
• Abilita / disabilita rapidamente facendo clic sull'icona nella barra delle applicazioni
• Piccolo e leggero sulle risorse di sistema

Il sito Web del prodotto sembra attualmente inattivo, ma ecco una copia del testo del sito su Archive.org .

Un link per il download è qui .

Esiste una semplice alternativa C ++ da 100 linee che è abbastanza simile alle soluzioni AutoHotKey

• invio di eventi della rotella di scorrimento verticale / orizzontale spostando la trackball mentre si tiene premuto uno dei pulsanti X e
• clic centrale quando si preme e si rilascia un pulsante X senza spostare la trackball.

https://github.com/Seelge/TrackballScroll

Modifica: le versioni più recenti forniscono un'icona systray, funzionano su Windows 10 e sono basate su C #.

Ecco lo script AutoHotKey che utilizzo. Scorri tenendo premuto il piccolo pulsante sinistro e facendo rotolare la palla su / giù. Tuttavia, facendo clic sul piccolo pulsante sinistro si fa ancora INDIETRO. Può anche scorrere verso sinistra / destra ma era troppo sensibile per me, quindi è commentato qui (il blocco che inizia con ;timesX := Abs(movedx) / 4).

Ho trovato la versione originale su http://www.autohotkey.com/board/topic/30816-simulate-scroll-wheel-using-right-mouse-button/ . Ho pubblicato la mia versione lì come anotherperson8923.

$*XButton1::
Hotkey, $*XButton1 Up, XButton1up, off
;KeyWait, XButton1, T0.4
;If ErrorLevel = 1
;{
   Hotkey, $*XButton1 Up, XButton1up, on
   MouseGetPos, ox, oy
   SetTimer, WatchTheMouse, 5
   movedx := 0
   movedy := 0
   pixelsMoved := 0
;   TrayTip, Scrolling started, Emulating scroll wheel
;}
;Else
;   Send {XButton1}
return

XButton1up:
Hotkey, $*XButton1 Up, XButton1up, off
SetTimer, WatchTheMouse, off
;TrayTip
If (pixelsMoved = 0)
{
    ;The mouse was not moved, send the click event
    ; (May want to make it PGUP or something)
    Send {XButton1}
    Send {XButton1Up}
}
return

WatchTheMouse:
MouseGetPos, nx, ny
movedx := movedx+nx-ox
movedy := movedy+ny-oy

pixelsMoved := pixelsMoved + Abs(nx-ox) + Abs(ny-oy)

;timesX := Abs(movedx) / 4
;ControlGetFocus, control, A
;Loop, %timesX%
;{
;    If (movedx > 0)
;    {
;        SendMessage, 0x114, 1, 0, %control%, A ; 0x114 is WM_HSCROLL
;        movedx := movedx - 4
;    }
;    Else
;    {
;        SendMessage, 0x114, 0, 0, %control%, A ; 0x114 is WM_HSCROLL
;        movedx := movedx + 4
;    }
;}

timesY := Abs(movedy) / 4
Loop, %timesY%
{
    If (movedy > 0)
    {
        Click WheelDown
        movedy := movedy - 4
    }
    Else
    {
        Click WheelUp
        movedy := movedy + 4
    }
}   

MouseMove ox, oy
return

È un peccato che Logitech non abbia implementato una simulazione della rotella di scorrimento. Il loro driver promette una funzionalità per farlo, ma non funziona per tutte le applicazioni, rendendolo abbastanza inutile. Erano così vicini alla creazione del mouse perfetto! :S

L'unica soluzione che ho trovato è utilizzare uno script AutoHotkey per questo. Con esso puoi far scorrere i piccoli pulsanti sinistra / destra su e giù. Funziona perfettamente, ma è una vera seccatura per configurarlo: dovrai prima imparare le basi di AutoHotkey. Se decidi di farlo, ecco il mio script AutoHotkey. È un adattamento della sceneggiatura originale di Jerbo . Un singolo clic inizierà a scorrere a un ritmo normale, ma un doppio o triplo clic inizierà a scorrere più velocemente.

; This script remaps the two small buttons on a Logitech Trackman® Marble® Mouse
; to act as scroll up and scroll down

global lastXButton1ClickTime := 0
global nrSubsequentXButton1Clicks := 0

ScrollTheWheel(direction, scrollKey)
{
    now := A_TickCount
    timeSinceLastClick := now - lastXButton1ClickTime 
    lastXButton1ClickTime := now
    if (timeSinceLastClick < 300)
    {
        nrSubsequentXButton1Clicks := nrSubsequentXButton1Clicks + 1
    }
    else
    {
        nrSubsequentXButton1Clicks := 1
    }        

    sleepingFraction := 5

    if (nrSubsequentXButton1Clicks <= 1)
        scrollSpeed := 30
    if (nrSubsequentXButton1Clicks == 2)
        scrollSpeed := 15
    if (nrSubsequentXButton1Clicks >= 3)
        scrollSpeed := 5

    timeSlept := scrollSpeed

    loop 
    {
        if (direction == 1) ; Scroll down
        {
            static downKeyState
            if (scrollKey == 0) 
                GetKeyState, downKeyState, XButton1, P
            else
                GetKeyState, downKeyState, PgDn, P

            if downKeyState = U ; The key has been released, so break out of the loop
               break

            if (timeSlept >= scrollSpeed)
            {
                Send {WheelDown}
                timeSlept = 0                
            }
        }
        else ; Scroll up
        {
            static upKeyState
            if (scrollKey == 0)
                GetKeyState, upKeyState, XButton2, P
            else
                GetKeyState, upKeyState, PgUp, P

            if upKeyState = U ; The key has been released, so break out of the loop
               break            

            if (timeSlept >= scrollSpeed)
            {
                Send {WheelUp}
                timeSlept = 0                
            }
        }   

        Sleep, sleepingFraction
        timeSlept := timeSlept + sleepingFraction
    }    
}

XButton2::
    ScrollTheWheel(0, 0)
    return
XButton1::
    ScrollTheWheel(1, 0)
    return
!PgUp::
    ScrollTheWheel(0, 1)
    return
!PgDn::
    ScrollTheWheel(1, 1)
    return

Ho appena ricevuto un mouse Logitech Marble e ho anche avuto il problema dello scorrimento. Quindi ho realizzato questo script su AutoHotKey. Il pulsante X sinistro consente lo scorrimento, il che significa che mentre sei in basso puoi scorrere verticalmente e orizzontalmente con la palla e spostarti avanti e indietro nel browser con i pulsanti sinistro e destro. Il pulsante X destro ha la stessa azione del pulsante centrale.

Sono su Windows 7.

#SINGLEINSTANCE FORCE  
GLOBAL status := "basic"
GLOBAL cnt_x
GLOBAL cnt_y

XButton2::MButton

$*XButton1::
    status := "scroll"
    cnt_x := 0
    cnt_y := 0
    MOUSEGETPOS, st_x, st_y
    SETTIMER, _scroll, 30
RETURN

$*XButton1 UP::
    status := "basic"
    SETTIMER, _scroll, OFF
RETURN

_scroll:
    MOUSEGETPOS, cur_x, cur_y
    MOUSEMOVE, st_x, st_y

IF(abs(cur_x-st_x) > abs(cur_y-st_y)) {
    cnt_x := cnt_x + (cur_x-st_x)
    ControlGetFocus, control, A 
    IF (cnt_x > 7) {
        cnt := floor(cnt_x / 8)
        LOOP, %cnt% {
            SendMessage, 0x114, 0, 0, %control%, A
        }
        cnt_x := cnt_x - 8*floor(cnt_x / 8)
    } ELSE IF (cnt_x < -7) {
        cnt := -ceil(cnt_x / 8)
        LOOP, %cnt% {
            SendMessage, 0x114, 1, 0, %control%, A
        }
        cnt_x := cnt_x - 8*ceil(cnt_x / 8)
    }
} ELSE {
    IF (cur_y >= st_y) {
        cnt_y := cnt_y + (cur_y-st_y)**1.2
    } ELSE {
        cnt_y := cnt_y -(st_y-cur_y)**1.2
    }   
    IF (cnt_y > 7) {
        cnt := floor(cnt_y / 8)
        LOOP, %cnt% {
            CLICK WheelUp
        }
        cnt_y := cnt_y - 8*floor(cnt_y / 8)
    } ELSE IF (cnt_y < -7) {
        cnt := -ceil(cnt_y / 8)
        LOOP, %cnt% {
            CLICK WheelDown
        }
        cnt_y := cnt_y - 8*ceil(cnt_y / 8)
    }
}   
RETURN

$*LButton::
    IF (status = "basic") {
        CLICK DOWN Left
    } ELSE IF (status = "scroll") {
        SEND {Browser_Back}
    }
RETURN

$*LButton UP::
    IF (status = "basic") {
        CLICK UP Left
    }
RETURN

$*RButton::
    IF (status = "basic") {
        CLICK DOWN Right
    } ELSE IF (status = "scroll") {
        SEND {Browser_Forward}
    }
RETURN

$*RButton UP::
    IF (status = "basic") {
        CLICK UP Right
    }
RETURN

A seconda del sistema operativo in uso, potresti essere in grado di configurare uno dei pulsanti per abilitare lo scorrimento spostando il puntatore quando tenuto. Ad esempio il seguente script abilita questo sul pulsante 10 del mio mouse (il pulsante "in alto al centro" del Logitech MX310):

#!/bin/sh
xinput set-prop "Logitech USB-PS/2 Optical Mouse" 290 10
xinput set-prop "Logitech USB-PS/2 Optical Mouse" 286 1
xinput set-prop "Logitech USB-PS/2 Optical Mouse" 287 6 7 4 5

Ci sono tali topi di marmo (topi) che hanno una rotella di scorrimento inclusa. Altrimenti, sembra che sarebbe necessaria un'app o uno script per un mouse senza ruote insieme all'uso di uno dei pulsanti per attivare una funzione di scorrimento (che hai notato in un commento a un'altra risposta, come soluzione non accettabile).

Quindi "Perché reinventare la ruota?" è un buon adagio in questo caso.

In questi esempi, l'elemento è installato fisicamente e ci sono molti tipi tra cui scegliere. Di seguito sono riportati due esempi e stili.

O qualcosa del genere: Adesso

Due opzioni non convenzionali

• Utilizza un trackpad Apple Magic oltre alla trackball. (Questa è la mia soluzione attuale) http://www.apple.com/magictrackpad/

• Acquista un controller leapmotion e usalo in aggiunta alla trackball. Agita la mano davanti al dispositivo per scorrere su e giù. https://www.leapmotion.com/product

Credito immagine http://www5.pcmag.com/media/images/393268-leap-motion-controller.jpg

Una soluzione semplice (ed ergonomica, oserei dire) è quella di mettere la funzione di scorrimento sulla mano sinistra.

Ciò potrebbe essere ottenuto utilizzando un mouse con la mano sinistra / utilizzando una tastiera con una rotella di scorrimento incorporata sul bordo sinistro / assegnando funzioni di scorrimento ai tasti di una tastiera programmabile con un programma come Mkey ( http: // www.seriosoft.org/en/index.php ).

Perché penso che sia più ergonomico, perché questo approccio distribuisce la tensione in modo più uniforme su entrambe le mani. (Ulteriori informazioni al riguardo: http://capsoff.org/checklist ).

Sono su Windows 7 e utilizzo la trackball ottica Kensington Orbit senza scorrimento : è una trackball a due pulsanti, senza i pulsanti X richiesti dalla maggior parte degli script e delle applicazioni AHK segnalati da altri.

Tuttavia, MouseImp funziona per me su Windows 7. È configurabile, ma l'ho configurato per right-click + rollfarmi una schermata di scorrimento. È più come un trascinamento, quindi il puntatore si sposta e hai solo una schermata alla volta [aggiorna: la velocità di scorrimento è configurabile, quindi può essere più di "una pagina"].

Allo stesso tempo, TrackballWorks di Kensington è stato configurato per consentirmi di scorrere verso il basso left-click + right-click. Sfortunatamente non può quindi scorrere indietro di una pagina alla volta (l'una o l'altra).

Questo non è un plug di prodotto - è proprio quello che ho scoperto di lavorare con questo modello / tipo di trackball .

Avvertenza: si fa costantemente clic con il tasto destro e sinistro, e questo può creare confusione, e i collegamenti vengono seguiti / attivati ​​quando si desidera semplicemente interrompere lo scorrimento . :::sospiro:::

Ho appena ricevuto una trackball wireless in orbita da Kensington, è piuttosto sorprendente. Hai la palla, hai entrambi i pulsanti su ogni lato e hai una sorta di cerchio al di fuori della trackball che rende possibile scorrere verso l'alto o verso il basso della pagina. Funziona davvero e sto usando su Windows e Mac OSX.

In realtà ho fatto qualcosa per questo usando AutoHotkey qualche tempo fa e ho pensato di condividerlo anche qui: Emulatore rotellina del mouse

Questo emula lo scorrimento della rotellina del mouse spostando il mouse mentre si tengono premuti i pulsanti sinistro e destro del mouse.

Puoi anche emulare un clic centrale facendo clic contemporaneamente sui pulsanti sinistro e destro del mouse.

Un'altra soluzione per Windows 7 che consente lo scorrimento in tutte le applicazioni, incluso Internet Explorer:

1. Installa AutoHotKey .
2. Salva questo script come scroll.ahksul desktop.
3. Fare clic con il tasto destro su scroll.ahk.
4. Seleziona Esegui script .
5. Conferma, se richiesto.

Ciò consentirà di tenere il piccolo pulsante destro scorrere verticalmente quando si sposta la trackball. Il piccolo pulsante sinistro è il pulsante Indietro.

Nel caso in cui il link al codice di Erik Elmore scompaia, eccolo qui:

;;
;; Emulate_Scrolling_Middle_Button.ahk
;; Author: Erik Elmore <erik@ironsavior.net>
;; Version: 1.1 (Aug 16, 2005)
;;
;; Enables you to use any key with cursor movement
;; to emulate a scrolling middle button.  While
;; the TriggerKey is held down, you may move the
;; mouse cursor up and down to send scroll wheel
;; events.  If the cursor does not move by the
;; time the TriggerKey is released, then a middle
;; button click is generated.  I wrote this for my
;; 4-button Logitech Marble Mouse (trackball),  
;; which has no middle button or scroll wheel.
;;

;; Configuration

;#NoTrayIcon

;; Higher numbers mean less sensitivity
esmb_Threshold = 7

;; This key/Button activates scrolling
esmb_TriggerKey = XButton2

;; End of configuration

#Persistent
CoordMode, Mouse, Screen
Hotkey, %esmb_TriggerKey%, esmb_TriggerKeyDown
HotKey, %esmb_TriggerKey% Up, esmb_TriggerKeyUp
esmb_KeyDown = n
SetTimer, esmb_CheckForScrollEventAndExecute, 10
return

esmb_TriggerKeyDown:
  esmb_Moved = n
  esmb_FirstIteration = y
  esmb_KeyDown = y
  MouseGetPos, esmb_OrigX, esmb_OrigY
  esmb_AccumulatedDistance = 0
return

esmb_TriggerKeyUp:
  esmb_KeyDown = n
  ;; Send a middle-click if we did not scroll
  if esmb_Moved = n
    MouseClick, Middle
return

esmb_CheckForScrollEventAndExecute:
  if esmb_KeyDown = n
    return

  MouseGetPos,, esmb_NewY
  esmb_Distance := esmb_NewY - esmb_OrigY
  if esmb_Distance
    esmb_Moved = y

  esmb_AccumulatedDistance := (esmb_AccumulatedDistance + esmb_Distance)
  esmb_Ticks := (esmb_AccumulatedDistance // esmb_Threshold) ; floor divide
  esmb_AccumulatedDistance := (esmb_AccumulatedDistance - (esmb_Ticks * esmb_Threshold))
  esmb_WheelDirection := "WheelDown"
  if (esmb_Ticks < 0) {
    esmb_WheelDirection := "WheelUp"
    esmb_Ticks := (-1 * esmb_Ticks)
  }

  ;; Do not send clicks on the first iteration
  if esmb_FirstIteration = y
    esmb_FirstIteration = n
  else {
    Loop % esmb_Ticks {
      MouseClick, %esmb_WheelDirection%
    }
  }

  MouseMove,esmb_OrigX,esmb_OrigY,0
return

Un altro utente di Trackman Marble qui.

Sto usando X-Mouse Button Control per l'emulazione di scorrimento. Questa implementazione di funzionalità non è perfetta lì (ancora?), Ma è molto più utilizzabile dell'implementazione di Logitech nel proprio software SetPoint ™.

Consiglio XMBC a tutti coloro che non vogliono scherzare con AutoHotKey e cercare qualcosa che funzioni.