Mercurial > hg > idav / file comparison

comparison: ui/qt/menu.cpp

ui/qt/menu.cpp

changeset 103
6606616eca9f
parent 0
2483f517c562
child 108
77254bd6dccb
equal deleted inserted replaced
102:64ded9f6a6c6 103:6606616eca9f
33 #include <QAction> 33 #include <QAction>
34 34
35 #include "menu.h" 35 #include "menu.h"
36 #include "toolkit.h" 36 #include "toolkit.h"
37 #include "../common/context.h" 37 #include "../common/context.h"
38 #include "../common/menu.h"
38 #include "../ui/properties.h" 39 #include "../ui/properties.h"
39 #include "../ui/window.h" 40 #include "../ui/window.h"
40 #include "stock.h" 41 #include "stock.h"
41 #include "container.h" 42 #include "container.h"
42 43
43 static UcxList *menus; 44
44 static UcxList *current; 45 static ui_menu_add_f createMenuItem[] = {
45 46 /* UI_MENU */ add_menu_widget,
46 /* -------------------------- UiMenu -------------------------- */ 47 /* UI_MENU_ITEM */ add_menuitem_widget,
47 48 /* UI_MENU_CHECK_ITEM */ add_checkitem_widget,
48 UiMenu::UiMenu(char* label) { 49 /* UI_MENU_RADIO_ITEM */ add_radioitem_widget,
49 this->items = NULL; 50 /* UI_MENU_ITEM_LIST */ add_menuitem_list_widget,
50 this->label = label; 51 /* UI_MENU_CHECKITEM_LIST */ add_menuitem_list_widget,
51 } 52 /* UI_MENU_RADIOITEM_LIST */ add_menuitem_list_widget,
52 53 /* UI_MENU_SEPARATOR */ add_menuseparator_widget
53 void UiMenu::addMenuItem(UiMenuItemI* item) { 54 };
54 items = ucx_list_append(items, item); 55
55 } 56 /*
56 57 * create all menu child items
57 void UiMenu::addTo(UiObject *obj, QMenuBar *menubar, QMenu *menu) { 58 */
58 QMenu *m = NULL; 59 static void add_menu_items(QMenu *parent, int i, UiMenu *menu, UiObject *obj) {
59 if(menubar) { 60 UiMenuItemI *it = menu->items_begin;
60 m = menubar->addMenu(label); 61 int index = 0;
61 } else { 62 while(it) {
62 m = menu->addMenu(label); 63 createMenuItem[it->type](parent, index, it, obj);
63 } 64 it = it->next;
64 65 index++;
65 UCX_FOREACH(elm, items) { 66 }
66 UiMenuItemI *item = (UiMenuItemI*)elm->data; 67 }
67 item->addTo(obj, NULL, m); 68
68 } 69 void add_menu_widget(QMenu *parent, int i, UiMenuItemI *item, UiObject *obj) {
69 } 70 UiMenu *m = (UiMenu*)item;
70 71 QMenu *menu = parent->addMenu(m->label);
71 72 add_menu_items(menu, i, m, obj);
72 /* -------------------------- UiMenuItem -------------------------- */ 73 }
73 74
74 UiMenuItem::UiMenuItem(char* label, ui_callback f, void* userdata) { 75 static UiAction* create_action(
75 this->label = label; 76 UiObject *obj,
76 this->callback = f; 77 const char *icon,
77 this->userdata = userdata; 78 const char *label,
78 this->groups = NULL; 79 ui_callback callback,
79 } 80 void *userdata,
80 81 int *states)
81 void UiMenuItem::addGroup(int group) { 82 {
82 groups = ucx_list_append(groups, (void*)(intptr_t)group);
83 }
84
85 void UiMenuItem::setCheckable(bool c) {
86 checkable = c;
87 }
88
89 void UiMenuItem::addTo(UiObject *obj, QMenuBar *menubar, QMenu *menu) {
90 QString str = QString::fromUtf8(label); 83 QString str = QString::fromUtf8(label);
91 UiAction *action = new UiAction(obj, str, callback, userdata); 84 UiAction *action = new UiAction(obj, str, callback, userdata);
92 action->setCheckable(checkable); 85 if(icon) {
93 if(checkable) { 86 action->setIcon(QIcon::fromTheme(icon));
94 action->setChecked(false); 87 action->setIconVisibleInMenu(true);
95 } 88 }
96 menu->addAction(action); 89
90 if(states) {
91 size_t nstates = uic_group_array_size(states);
92 uic_add_group_widget_i(obj->ctx, action, (ui_enablefunc)ui_action_enable, states, nstates);
93 action->setEnabled(false);
94 }
95
96 return action;
97 }
98
99 void add_menuitem_widget(QMenu *parent, int i, UiMenuItemI *item, UiObject *obj) {
100 UiMenuItem *it = (UiMenuItem*)item;
101 UiAction *action = create_action(obj, it->icon, it->label, it->callback, it->userdata, it->groups);
102 parent->addAction(action);
97 QObject::connect(action, SIGNAL(triggered()), action, SLOT(trigger())); 103 QObject::connect(action, SIGNAL(triggered()), action, SLOT(trigger()));
98 } 104 }
99 105
100 106 void add_menuseparator_widget(QMenu *parent, int i, UiMenuItemI *item, UiObject *obj) {
101 /* -------------------------- UiStMenuItem -------------------------- */ 107 parent->addSeparator();
102 108 }
103 UiStMenuItem::UiStMenuItem(char* stockid, ui_callback f, void* userdata) { 109
104 this->stockid = stockid; 110 void add_checkitem_widget(QMenu *parent, int i, UiMenuItemI *item, UiObject *obj) {
105 this->callback = f; 111 UiMenuCheckItem *it = (UiMenuCheckItem*)item;
106 this->userdata = userdata; 112
107 this->groups = NULL; 113 UiAction *action = create_action(obj, it->icon, it->label, it->callback, it->userdata, it->groups);
108 } 114 parent->addAction(action);
109
110 void UiStMenuItem::addGroup(int group) {
111 groups = ucx_list_append(groups, (void*)(intptr_t)group);
112 }
113
114 void UiStMenuItem::addTo(UiObject *obj, QMenuBar *menubar, QMenu *menu) {
115 UiStockItem *stockItem = ui_get_stock_item(stockid);
116
117 QString str = QString::fromUtf8(stockItem->label);
118 UiAction *action = new UiAction(obj, str, callback, userdata);
119 action->setIcon(QIcon::fromTheme(stockItem->icon_name));
120 action->setIconVisibleInMenu(true);
121 menu->addAction(action);
122 //UiEventWrapper *ev = new UiEventWrapper(callback, userdata);
123 QObject::connect(action, SIGNAL(triggered()), action, SLOT(trigger()));
124 }
125
126
127 /* -------------------------- UiMenuSeparator -------------------------- */
128
129 void UiMenuSeparator::addTo(UiObject* obj, QMenuBar* menubar, QMenu* menu) {
130 menu->addSeparator();
131 }
132
133
134 /* -------------------------- UiCheckItemNV -------------------------- */
135
136 UiCheckItemNV::UiCheckItemNV(char* label, char* varname) {
137 this->label = label;
138 this->varname = varname;
139 }
140
141 void UiCheckItemNV::addTo(UiObject* obj, QMenuBar* menubar, QMenu* menu) {
142 QString str = QString::fromUtf8(label);
143 UiAction *action = new UiAction(obj, str, NULL, NULL);
144 action->setCheckable(true); 115 action->setCheckable(true);
145 menu->addAction(action); 116 action->prepare_event = ui_checkableaction_prepare_event;
146 QObject::connect(action, SIGNAL(triggered()), action, SLOT(trigger())); 117
147 118 UiVar* var = uic_widget_var(obj->ctx, obj->ctx, NULL, it->varname, UI_VAR_INTEGER);
148 UiVar *var = uic_connect_var(obj->ctx, varname, UI_VAR_INTEGER);
149 if(var) { 119 if(var) {
150 UiInteger *value = (UiInteger*)var->value; 120 UiInteger *value = (UiInteger*)var->value;
151 action->setChecked(value->value);
152 value->obj = action; 121 value->obj = action;
153 value->get = ui_checkitem_get; 122 value->get = ui_checkableaction_get;
154 value->set = ui_checkitem_set; 123 value->set = ui_checkableaction_set;
155 value = 0; 124
125 action->setChecked((bool)value->value);
126 }
127 action->var = var;
128 }
129
130 void add_radioitem_widget(QMenu *parent, int index, UiMenuItemI *item, UiObject *obj) {
131 UiMenuRadioItem *it = (UiMenuRadioItem*)item;
132
133 UiAction *action = create_action(obj, it->icon, it->label, it->callback, it->userdata, it->groups);
134 parent->addAction(action);
135 action->setCheckable(true);
136 action->prepare_event = ui_actiongroup_prepare_event;
137
138 UiVar* var = uic_widget_var(obj->ctx, obj->ctx, NULL, it->varname, UI_VAR_INTEGER);
139 if(var) {
140 UiInteger *value = (UiInteger*)var->value;
141 QActionGroup *group = (QActionGroup*)value->obj;
142 if(!group) {
143 group = new QActionGroup(parent);
144 value->obj = group;
145 }
146 group->addAction(action);
147 value->get = ui_actiongroup_get;
148 value->set = ui_actiongroup_set;
149 if(value->value != 0) {
150 ui_actiongroup_set(value, value->value);
151 }
152 }
153 action->var;
154 }
155
156 void ui_actiongroup_prepare_event(UiEvent *event, UiAction *action) {
157 if(action->var) {
158 UiInteger *value = (UiInteger*)action->var->value;
159 event->eventdata = value;
160 event->intval = value->get(value);
161 }
162 }
163
164 int64_t ui_actiongroup_get(UiInteger *value) {
165 QActionGroup *group = (QActionGroup*)value->obj;
166 auto actions = group->actions();
167 int i = 1;
168 foreach(const QAction *action, actions) {
169 if(action->isChecked()) {
170 value->value = i;
171 break;
172 }
173 i++;
174 }
175 return value->value;
176 }
177
178 void ui_actiongroup_set(UiInteger *value, int64_t i) {
179 QActionGroup *group = (QActionGroup*)value->obj;
180 auto actions = group->actions();
181 if(i > 0) {
182 if(i-1 < actions.size()) {
183 actions[i]->setEnabled(true);
184 }
185 value->value = i;
156 } else { 186 } else {
157 // TODO: error 187 foreach(QAction *action, actions) {
158 } 188 action->setEnabled(false);
159 } 189 }
160 190 value->value = 0;
161 191 }
162 /* -------------------------- UiAction -------------------------- */ 192 }
163 193
164 UiAction::UiAction(UiObject *obj, QString &label, ui_callback f, void* userdata) : QAction(label, NULL) { 194 void add_menuitem_list_widget(QMenu *parent, int i, UiMenuItemI *item, UiObject *obj) {
165 //QAction(label, NULL); 195
166 this->obj = obj; 196 }
167 this->callback = f; 197
168 this->userdata = userdata; 198
169 } 199 void ui_add_menus(UiObject *obj, QMainWindow *window) {
170 200 UiMenu *menus_begin = uic_get_menu_list();
171 void UiAction::trigger() { 201 if(menus_begin == NULL) {
172 if(!callback) {
173 return; 202 return;
174 } 203 }
175 204
176 UiEvent e;
177 e.obj = obj;
178 e.window = obj->window;
179 e.document = obj->ctx->document;
180 e.eventdata = NULL;
181
182 if(isCheckable()) {
183 e.intval = isChecked();
184 } else {
185 e.intval = 0;
186 }
187
188 callback(&e, userdata);
189 }
190
191
192 void ui_menu(char *label) {
193 // free current menu hierarchy
194 ucx_list_free(current);
195
196 // create menu
197 UiMenu *menu = new UiMenu(label);
198
199 current = ucx_list_prepend(NULL, menu);
200 menus = ucx_list_append(menus, menu);
201 }
202
203 void ui_submenu(char *label) {
204 UiMenu *menu = new UiMenu(label);
205
206 // add submenu to current menu
207 UiMenu *cm = (UiMenu*)current->data;
208 cm->addMenuItem(menu);
209
210 // set the submenu to current menu
211 current = ucx_list_prepend(current, menu);
212 }
213
214 void ui_submenu_end() {
215 if(ucx_list_size(current) < 2) {
216 return;
217 }
218 current = ucx_list_remove(current, current);
219 //UcxList *c = current;
220 }
221
222
223 void ui_menuitem(char *label, ui_callback f, void *userdata) {
224 ui_menuitem_gr(label, f, userdata, -1);
225 }
226
227 void ui_menuitem_st(char *stockid, ui_callback f, void *userdata) {
228 ui_menuitem_stgr(stockid, f, userdata, -1);
229 }
230
231 void ui_menuitem_gr(char *label, ui_callback f, void *userdata, ...) {
232 if(!current) {
233 return;
234 }
235
236 UiMenuItem *item = new UiMenuItem(label, f, userdata);
237
238 // add groups
239 va_list ap;
240 va_start(ap, userdata);
241 int group;
242 while((group = va_arg(ap, int)) != -1) {
243 item->addGroup(group);
244 }
245 va_end(ap);
246
247 UiMenu *cm = (UiMenu*)current->data;
248 cm->addMenuItem(item);
249 }
250
251 void ui_menuitem_stgr(char *stockid, ui_callback f, void *userdata, ...) {
252 if(!current) {
253 return;
254 }
255
256 UiStMenuItem *item = new UiStMenuItem(stockid, f, userdata);
257
258 // add groups
259 va_list ap;
260 va_start(ap, userdata);
261 int group;
262 while((group = va_arg(ap, int)) != -1) {
263 item->addGroup(group);
264 }
265 va_end(ap);
266
267 UiMenu *cm = (UiMenu*)current->data;
268 cm->addMenuItem(item);
269 }
270
271 void ui_menuseparator() {
272 if(!current) {
273 return;
274 }
275
276 UiMenuSeparator *item = new UiMenuSeparator();
277 UiMenu *cm = (UiMenu*)current->data;
278 cm->addMenuItem(item);
279 }
280
281 void ui_checkitem(char *label, ui_callback f, void *userdata) {
282 if(!current) {
283 return;
284 }
285
286 UiMenuItem *item = new UiMenuItem(label, f, userdata);
287 item->setCheckable(true);
288
289 UiMenu *cm = (UiMenu*)current->data;
290 cm->addMenuItem(item);
291 }
292
293 void ui_checkitem_nv(char *label, char *vname) {
294 if(!current) {
295 return;
296 }
297
298 UiCheckItemNV *item = new UiCheckItemNV(label, vname);
299
300 UiMenu *cm = (UiMenu*)current->data;
301 cm->addMenuItem(item);
302 }
303
304 void ui_menuitem_list(UiList *items, ui_callback f, void *userdata) {
305
306 }
307
308 void ui_add_menus(UiObject *obj, QMainWindow *window) {
309 QMenuBar *mb = window->menuBar(); 205 QMenuBar *mb = window->menuBar();
310 206
311 UCX_FOREACH(elm, menus) { 207 UiMenu *ls = menus_begin;
312 UiMenu *menu = (UiMenu*)elm->data; 208 while(ls) {
313 menu->addTo(obj, mb, NULL); 209 if(ls->item.type == UI_MENU) {
314 } 210 QMenu *menu = mb->addMenu(ls->label);
315 } 211 add_menu_items(menu, 0, ls, obj);
316 212 }
317 int ui_checkitem_get(UiInteger *i) { 213 ls = (UiMenu*)ls->item.next;
318 QAction *action = (QAction*)i->obj; 214 }
319 i->value = action->isChecked(); 215 }
320 return i->value; 216
321 } 217 void ui_checkableaction_prepare_event(UiEvent *event, UiAction *action) {
322 218 if(action->var) {
323 void ui_checkitem_set(UiInteger *i, int value) { 219 event->eventdata = action->var->value;
324 QAction *action = (QAction*)i->obj; 220 }
325 i->value = value; 221 event->intval = action->isChecked();
326 action->setChecked(value); 222 }
327 } 223
328 224 int64_t ui_checkableaction_get(UiInteger *value) {
329 225 UiAction *action= (UiAction*)value->obj;
330 /* 226 value->value = action->isChecked();
331 * widget menu functions 227 return value->value;
332 */ 228 }
333 229
334 UiContextMenuHandler::UiContextMenuHandler(QWidget *widget, QMenu* menu) { 230 void ui_checkableaction_set(UiInteger *value, int64_t i) {
335 this->widget = widget; 231 UiAction *action = (UiAction*)value->obj;
336 this->menu = menu; 232 value->value = i;
337 } 233 if(i != 0) {
338 234 action->setChecked((bool)i);
339 void UiContextMenuHandler::contextMenuEvent(const QPoint & pos) { 235 }
340 menu->popup(widget->mapToGlobal(pos)); 236 }
341 } 237
342 UIMENU ui_contextmenu(UiObject *obj) {
343 UiContainer *ct = uic_get_current_container(obj);
344 return ui_contextmenu_w(obj, ct->current);
345 }
346
347 UIMENU ui_contextmenu_w(UiObject *obj, UIWIDGET widget) {
348 UiContainer *ct = uic_get_current_container(obj);
349
350 QMenu *menu = new QMenu(widget);
351 widget->setContextMenuPolicy(Qt::CustomContextMenu);
352
353 UiContextMenuHandler *handler = new UiContextMenuHandler(widget, menu);
354 QObject::connect(
355 widget,
356 SIGNAL(customContextMenuRequested(QPoint)),
357 handler,
358 SLOT(contextMenuEvent(QPoint)));
359
360 ct->menu = menu;
361
362 return menu;
363 }
364
365 void ui_contextmenu_popup(UIMENU menu) {
366
367 }
368
369 void ui_widget_menuitem(UiObject *obj, char *label, ui_callback f, void *userdata) {
370 ui_widget_menuitem_gr(obj, label, f, userdata, -1);
371 }
372
373 void ui_widget_menuitem_gr(UiObject *obj, char *label, ui_callback f, void *userdata, ...) {
374 UiContainer *ct = uic_get_current_container(obj);
375 if(!ct->menu) {
376 return;
377 }
378
379 // add groups
380 UcxList *groups = NULL;
381 va_list ap;
382 va_start(ap, userdata);
383 int group;
384 while((group = va_arg(ap, int)) != -1) {
385 ucx_list_append(groups, (void*)(intptr_t)group);
386 }
387 va_end(ap);
388
389 // create menuitem
390 QString str = QString::fromUtf8(label);
391 UiAction *action = new UiAction(obj, str, f, userdata);
392 ct->menu->addAction(action);
393 QObject::connect(action, SIGNAL(triggered()), action, SLOT(trigger()));
394 }
395
396 void ui_widget_menuitem_st(UiObject *obj, char *stockid, ui_callback f, void *userdata) {
397 ui_widget_menuitem_stgr(obj, stockid, f, userdata, -1);
398 }
399
400 void ui_widget_menuitem_stgr(UiObject *obj, char *stockid, ui_callback f, void *userdata, ...) {
401 UiContainer *ct = uic_get_current_container(obj);
402 if(!ct->menu) {
403 return;
404 }
405
406 // add groups
407 UcxList *groups = NULL;
408 va_list ap;
409 va_start(ap, userdata);
410 int group;
411 while((group = va_arg(ap, int)) != -1) {
412 ucx_list_append(groups, (void*)(intptr_t)group);
413 }
414 va_end(ap);
415
416 // create menuitem
417 UiStockItem *stockItem = ui_get_stock_item(stockid);
418
419 QString str = QString::fromUtf8(stockItem->label);
420 UiAction *action = new UiAction(obj, str, f, userdata);
421 action->setIcon(QIcon::fromTheme(stockItem->icon_name));
422 action->setIconVisibleInMenu(true);
423 ct->menu->addAction(action);
424 QObject::connect(action, SIGNAL(triggered()), action, SLOT(trigger()));
425 }

Mercurial Repository: idav

mercurial