src/drivers/Base/Fl_Base_Pen_Events.cxx


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200

//
// Implementation of default Pen/Tablet event driver.
//
// Copyright 2025 by Bill Spitzak and others.
//
// This library is free software. Distribution and use rights are outlined in
// the file "COPYING" which should have been included with this file.  If this
// file is missing or damaged, see the license at:
//
//     https://www.fltk.org/COPYING.php
//
// Please see the following page on how to report bugs and issues:
//
//     https://www.fltk.org/bugs.php
//

#include "src/drivers/Base/Fl_Base_Pen_Events.H"
#include <stdlib.h>


class Fl_Widget;


Fl_Pen_EventData fl_pen_event_data;
Fl_Pen_SubscriberList fl_pen_subscriber_list;
Fl_Pen_Subscriber *fl_pen_pushed = 0;
Fl_Pen_Subscriber *fl_pen_below = 0;


void fl_pen_event_data_init(Fl_Pen_EventData *d) {
  d->x = 0.0;
  d->y = 0.0;
  d->rx = 0.0;
  d->ry = 0.0;
  d->tilt_x = 0.0;
  d->tilt_y = 0.0;
  d->pressure = 1.0;
  d->proximity = 0.0;
  d->barrel_pressure = 0.0;
  d->twist = 0.0;
  d->pen_id = 0;
  d->state = (Fl_Pen_State)0;
  d->trigger = (Fl_Pen_State)0;
}


// ---- Fl_Pen_SubscriberList implementation ------------------------------------

Fl_Pen_SubscriberList::Fl_Pen_SubscriberList() {
  items_ = 0;
  widgets_ = 0;
  count_ = 0;
  alloc_ = 0;
}

Fl_Pen_SubscriberList::~Fl_Pen_SubscriberList() {
  int i;
  for (i = 0; i < count_; i++) {
    delete items_[i];
  }
  if (items_) free(items_);
  if (widgets_) free(widgets_);
}

/* Remove subscribers that have a 0 as a widget */
void Fl_Pen_SubscriberList::cleanup() {
  int i, j;
  for (i = 0, j = 0; i < count_; i++) {
    if (items_[i]->widget()) {
      if (i != j) {
        items_[j] = items_[i];
        widgets_[j] = widgets_[i];
      }
      j++;
    } else {
      delete items_[i];
    }
  }
  count_ = j;
}

Fl_Pen_Subscriber *Fl_Pen_SubscriberList::find(Fl_Widget *w) {
  int i;
  for (i = 0; i < count_; i++) {
    if (widgets_[i] == w) return items_[i];
  }
  return 0;
}

/* Add a new subscriber, or return an existing one. */
Fl_Pen_Subscriber *Fl_Pen_SubscriberList::add(Fl_Widget *w) {
  Fl_Pen_Subscriber *existing;
  cleanup();
  existing = find(w);
  if (existing) return existing;

  if (count_ >= alloc_) {
    int new_alloc = alloc_ ? alloc_ * 2 : 8;
    items_ = (Fl_Pen_Subscriber **)realloc(items_, new_alloc * sizeof(Fl_Pen_Subscriber *));
    widgets_ = (Fl_Widget **)realloc(widgets_, new_alloc * sizeof(Fl_Widget *));
    alloc_ = new_alloc;
  }
  Fl_Pen_Subscriber *sub = new Fl_Pen_Subscriber(w);
  items_[count_] = sub;
  widgets_[count_] = w;
  count_++;
  return sub;
}

/* Remove a subscriber from the list. */
void Fl_Pen_SubscriberList::remove(Fl_Widget *w) {
  int i;
  for (i = 0; i < count_; i++) {
    if (widgets_[i] == w) {
      items_[i]->clear();
      delete items_[i];
      count_--;
      if (i < count_) {
        items_[i] = items_[count_];
        widgets_[i] = widgets_[count_];
      }
      return;
    }
  }
}

// ---- Fl_Pen_Driver implementation --------------------------------------------
// Override the methods below to handle subscriptions and queries by user apps.

void Fl_Pen_Driver::subscribe(Fl_Widget* widget) {
  if (widget == 0) return;
  fl_pen_subscriber_list.add(widget);
}

void Fl_Pen_Driver::unsubscribe(Fl_Widget* widget) {
  if (widget == 0) return;
  fl_pen_subscriber_list.remove(widget);
}

void Fl_Pen_Driver::release() {
  fl_pen_pushed = 0;
  fl_pen_below = 0;
}

Fl_Pen_Trait Fl_Pen_Driver::traits() {
  return FL_PEN_TRAIT_NONE;
}

Fl_Pen_Trait Fl_Pen_Driver::pen_traits(int pen_id) {
  (void)pen_id;
  return FL_PEN_TRAIT_NONE;
}

// ---- Fl_Pen API --------------------------------------------------------------

void Fl_Pen_subscribe(Fl_Widget* widget) {
  fl_pen_driver->subscribe(widget);
}

void Fl_Pen_unsubscribe(Fl_Widget* widget) {
  fl_pen_driver->unsubscribe(widget);
}

void Fl_Pen_release(void) {
  fl_pen_driver->release();
}

Fl_Pen_Trait Fl_Pen_driver_traits(void) {
  return fl_pen_driver->traits();
}

Fl_Pen_Trait Fl_Pen_pen_traits(int pen_id) {
  return fl_pen_driver->pen_traits(pen_id);
}

double Fl_Pen_event_x(void) { return fl_pen_event_data.x; }

double Fl_Pen_event_y(void) { return fl_pen_event_data.y; }

double Fl_Pen_event_x_root(void) { return fl_pen_event_data.rx; }

double Fl_Pen_event_y_root(void) { return fl_pen_event_data.ry; }

int Fl_Pen_event_pen_id(void) { return fl_pen_event_data.pen_id; }

double Fl_Pen_event_pressure(void) { return fl_pen_event_data.pressure; }

double Fl_Pen_event_barrel_pressure(void) { return fl_pen_event_data.barrel_pressure; }

double Fl_Pen_event_tilt_x(void) { return fl_pen_event_data.tilt_x; }

double Fl_Pen_event_tilt_y(void) { return fl_pen_event_data.tilt_y; }

double Fl_Pen_event_twist(void) { return fl_pen_event_data.twist; }

double Fl_Pen_event_proximity(void) { return fl_pen_event_data.proximity; }

Fl_Pen_State Fl_Pen_event_state(void) { return fl_pen_event_data.state; }

Fl_Pen_State Fl_Pen_event_trigger(void) { return fl_pen_event_data.trigger; }