remédio para um trackball sem roda de rolagem?

Estou pensando em comprar um trackball e minha opção é o mármore trackman da Logitech. Mas então descobri que não há roda de rolagem. Como você lida com isso? Definitivamente, quero comprar um trackball com roda de rolagem? Eu rolo muito usando o facebook.

Não quero clicar com o dedo indicador e o dedo médio, para que alguns mouses de trackball não funcionem para mim, como o Trackman Wheel.

Se você estiver no Windows, sugiro experimentar o AutoHotKey, outros usuários já enfrentaram a rolagem com o Marble Mouse (usei o script na parte inferior):

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

A solução da Logitech que acompanha os drivers é estranha: você clica uma vez para ativar a rolagem em quatro direções e clica novamente para desativá-la. Você não pode segurar e rolar o que eu procurava. Acabei desinstalando o software deles.

Eu tenho o mesmo trackball e a solução é muito elegante: quando você clica em um botão escolhido, a bola se torna uma roda de rolagem. Eu escolhi o grande botão direito que pressiono com o dedo mindinho.

Isso é muito conveniente e leva apenas alguns dias para se acostumar.

Você rapidamente considerará que qualquer roda de rolagem (em um mouse ou trackball) é algo inutilizável. Confie em mim, vale a pena ;-)

Vantagens:

• Rolagem 2D em vez de 1D
• rolagem mais rápida e precisa do que uma roda
• mais confortável para rolagem longa (graças à inércia da bola). Perfeito para o seu exemplo no facebook.

Eu não posso mais viver sem isso.

Configurar isso em qualquer sistema operacional Linux não é difícil. Requer apenas que você crie um arquivo /etc/X11/xorg.conf (veja minha configuração aqui: Configure um trackball no Linux sem editar o Xorg.conf )

Mais detalhes podem ser encontrados aqui: https://help.ubuntu.com/community/Logitech_Marblemouse_USB

No Windows, não tenho experiência, mas acho que uma ferramenta de configuração é fornecida com o trackball.

Você pode experimentar o Marble Mouse Scroll Wheel, desenvolvido especialmente para esse mouse:

A Roda de rolagem do Marble Marble, ou apenas a Marble Scroll, é um pequeno programa projetado para simular uma roda de rolagem em qualquer trackball ou mouse sem um. Foi projetado especificamente para o Logitech Marble Mouse, mas pode funcionar com qualquer mouse ou trackball padrão. Ele foi projetado para Windows 2000 e superior.

O Marble Scroll substitui as funções Autoscroll e Universal Scroll da Logitech; nem emulam adequadamente uma roda de rolagem real e ambos têm limitações e falhas.

O Marble Scroll funciona com qualquer mouse ou trackball e não requer a instalação dos drivers SetPoint ou MouseWare da Logitech.

Recursos

• Adicione uma roda de rolagem a qualquer mouse com mais de dois botões
• Compatibilidade com a maioria dos aplicativos que suportam uma roda de rolagem (para qualquer tipo de entrada)
• Aceleração ajustável
• Distância de rolagem ajustável (por "etapa" - veja abaixo)
• Rolagem passo a passo para simular uma roda real do mouse
• Comutador de modo rápido para a esquerda / direita
• Ativar / desativar rapidamente, clicando no ícone da bandeja
• Pequeno e leve nos recursos do sistema

O site do produto parece atualmente inativo, mas aqui está uma cópia do texto do site no Archive.org .

Um link para download está aqui .

Existe uma alternativa C ++ simples de 100 linhas, que é bastante semelhante às soluções AutoHotKey, ou seja,

• enviando eventos de roda de rolagem vertical / horizontal movendo o trackball enquanto mantém pressionado um dos botões X e
• clique no meio ao pressionar e soltar um botão X sem mover o trackball.

https://github.com/Seelge/TrackballScroll

Editar: as versões mais recentes fornecem um ícone de bandeja, funcionam no Windows 10 e são baseadas em C #.

Aqui está o script AutoHotKey que eu uso. Você rola pressionando o botão pequeno esquerdo e rolando a bola para cima / baixo. No entanto, clicar no botão pequeno esquerdo ainda faz VOLTAR. Ele também pode rolar para a esquerda / direita, mas isso foi muito sensível para mim, por isso é comentado aqui (o bloco que começa com ;timesX := Abs(movedx) / 4).

Encontrei a versão original em http://www.autohotkey.com/board/topic/30816-simulate-scroll-wheel-using-right-mouse-button/ . Publiquei minha versão lá como 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

É uma pena que a Logitech não tenha implementado uma simulação de roda de rolagem. O driver deles promete um recurso para fazê-lo, mas não funciona para todos os aplicativos, tornando-o bastante inútil. Eles estavam tão perto de criar o mouse perfeito! : s

A única solução alternativa que eu encontrei é usar um script AutoHotkey para isso. Com ele, você pode fazer os pequenos botões esquerdo / direito rolar para cima e para baixo. Funciona perfeitamente, mas é um verdadeiro aborrecimento configurá-lo: você precisará aprender o básico do AutoHotkey primeiro. Se você decidir fazer isso, aqui está o meu script AutoHotkey. É uma adaptação do roteiro original de Jerbo . Um único clique começará a rolar em um ritmo normal, mas um clique duplo ou triplo começará a rolar mais rapidamente.

; 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

Acabei de adquirir um mouse Logitech Marble e também tive o problema de rolar. Então, eu fiz esse script no AutoHotKey. O Xbutton esquerdo permite a rolagem, o que significa que, enquanto para baixo, você pode rolar vertical e horizontalmente com a bola e avançar e retroceder no navegador com os botões esquerdo e direito. O Xbutton direito tem a mesma ação que o botão do meio.

Estou no 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

Dependendo do seu sistema operacional, você poderá configurar um dos botões para ativar a rolagem movendo o ponteiro quando pressionado. Por exemplo, o script a seguir habilita isso no botão 10 do meu mouse (o botão "superior central" do 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

Existem ratos de mármore (ratos) que incluem uma roda de rolagem. Caso contrário, parece que um aplicativo ou algum script seria necessário para um mouse sem rodas, juntamente com o uso de um dos botões para ativar uma função de rolagem (que você anotou em um comentário para outra resposta, como uma solução não aceitável).

Então "Por que reinventar a roda?" é um bom provérbio neste caso.

Nesses exemplos, o elemento é instalado fisicamente e há muitos tipos para você escolher. Abaixo estão dois exemplos e estilos.

Ou algo assim: Adesso

Duas opções não convencionais

• Use um Apple Magic Trackpad além do trackball. (Esta é a minha solução atual) http://www.apple.com/magictrackpad/

• Compre um controlador leapmotion e use-o além do trackball. Agite sua mão na frente do dispositivo para rolar para cima e para baixo. https://www.leapmotion.com/product

Crédito de imagem http://www5.pcmag.com/media/images/393268-leap-motion-controller.jpg

Uma solução simples (e ergonômica, ouso dizer) é colocar a função de rolagem no lado esquerdo.

Isso pode ser conseguido usando um mouse com a mão esquerda / usando um teclado com uma roda de rolagem embutida na borda esquerda / atribuindo funções de rolagem às teclas de um teclado programável com um programa como Mkey ( http: // www.seriosoft.org/en/index.php ).

Por que acho isso mais ergonômico - porque essa abordagem distribui a tensão de maneira mais uniforme nas duas mãos. (Mais sobre isso: http://capsoff.org/checklist ).

Estou no Windows7 e uso o Trackball Óptico Kensington Orbit sem rolagem - é um trackball com dois botões, sem os botões X exigidos pela maioria dos scripts e aplicativos AHK apontados por outros.

No entanto, o MouseImp está funcionando para mim no Windows7. É configurável, mas eu o configurei para right-click + rollobter uma tela de rolagem. É mais como uma chatice, então o ponteiro se move, e você só tem uma tela por vez [atualização: a taxa de rolagem é configurável, portanto pode ser mais do que "uma página"].

Ao mesmo tempo, o TrackballWorks da Kensington foi configurado para fornecer uma rolagem de página para baixo left-click + right-click. Infelizmente, não é possível rolar novamente uma página de cada vez (uma ou outra).

Este não é um plug de produto - é exatamente o que eu descobri para trabalhar com este modelo / tipo de trackball .

Advertência: você está constantemente clicando com o botão direito e esquerdo, e isso pode causar confusão, e os links sendo seguidos / ativados por js quando você deseja parar de rolar . :::suspiro:::

Acabei de receber um trackball sem fio em órbita de kensington, é incrível. Você tem a bola, os dois botões de cada lado e um círculo fora do trackball que possibilita rolar para cima ou para baixo na página. Realmente funciona, e estou usando no Windows e Mac OSX.

Na verdade, eu criei algo para isso usando o AutoHotkey há algum tempo e achei que eu também compartilharia aqui: Mouse Wheel Emulator

Isso emula a rolagem da roda do mouse movendo o mouse enquanto mantém pressionados os botões esquerdo e direito do mouse.

Você também pode emular um clique do meio clicando nos botões esquerdo e direito do mouse ao mesmo tempo.

Outra solução para o Windows 7 que permite rolar em todos os aplicativos, incluindo o Internet Explorer:

1. Instale o AutoHotKey .
2. Salve esse script como scroll.ahko Desktop.
3. Clique com o botão direito do mouse em scroll.ahk.
4. Selecione Executar Script .
5. Confirme, se solicitado.

Isso fará com que segurar o pequeno botão direito rolar verticalmente ao mover o trackball. O pequeno botão esquerdo é o botão Voltar.

Caso o link para o código de Erik Elmore desapareça, aqui está:

;;
;; Emulate_Scrolling_Middle_Button.ahk
;; Author: Erik Elmore <[email protected]>
;; 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

Outro usuário do Trackman Marble aqui.

Estou usando o X-Mouse Button Control para emulação de rolagem. Essa implementação de recurso ainda não é perfeita (ainda?), Mas é muito mais utilizável que a implementação da Logitech em seu próprio software SetPoint ™.

Eu recomendo o XMBC para quem não quiser mexer no AutoHotKey e procurar algo que simplesmente funcione.