src/dockedapp.c

   1 /* dockedapp.c- docked application settings panel
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1998-2003 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License along
  18  *  with this program; if not, write to the Free Software Foundation, Inc.,
  19  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "wconfig.h"
  23
  24 #include <X11/Xlib.h>
  25 #include <X11/Xutil.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include "WindowMaker.h"
  30 #include "window.h"
  31 #include "icon.h"
  32 #include "appicon.h"
  33 #include "dock.h"
  34 #include "dockedapp.h"
  35 #include "dialog.h"
  36 #include "funcs.h"
  37 #include "defaults.h"
  38 #include "framewin.h"
  39 #include "xinerama.h"
  40
  41 /**** Global variables ****/
  42 extern WPreferences wPreferences;
  43
  44 static void updateCommand(WAppIcon * icon, char *command)
  45 {
  46         if (icon->command)
  47                 wfree(icon->command);
  48         if (command && (command[0] == 0 || (command[0] == '-' && command[1] == 0))) {
  49                 wfree(command);
  50                 command = NULL;
  51         }
  52         icon->command = command;
  53
  54         if (!icon->wm_class && !icon->wm_instance && icon->command && strlen(icon->command) > 0) {
  55                 icon->forced_dock = 1;
  56         }
  57 }
  58
  59 static void updatePasteCommand(WAppIcon * icon, char *command)
  60 {
  61         if (icon->paste_command)
  62                 wfree(icon->paste_command);
  63         if (command && (command[0] == 0 || (command[0] == '-' && command[1] == 0))) {
  64                 wfree(command);
  65                 command = NULL;
  66         }
  67         icon->paste_command = command;
  68 }
  69
  70 #ifdef XDND
  71 static void updateDNDCommand(WAppIcon * icon, char *command)
  72 {
  73         if (icon->dnd_command)
  74                 wfree(icon->dnd_command);
  75         if (command && (command[0] == 0 || (command[0] == '-' && command[1] == 0))) {
  76                 wfree(command);
  77                 command = NULL;
  78         }
  79         icon->dnd_command = command;
  80 }
  81 #endif                          /* XDND */
  82
  83 static void updateSettingsPanelIcon(AppSettingsPanel * panel)
  84 {
  85         char *file;
  86
  87         file = WMGetTextFieldText(panel->iconField);
  88         if (!file)
  89                 WMSetLabelImage(panel->iconLabel, NULL);
  90         else {
  91                 char *path;
  92
  93                 path = FindImage(wPreferences.icon_path, file);
  94                 if (!path) {
  95                         wwarning(_("could not find icon %s, used in a docked application"), file);
  96                         wfree(file);
  97                         WMSetLabelImage(panel->iconLabel, NULL);
  98                         return;
  99                 } else {
 100                         WMPixmap *pixmap;
 101                         RColor color;
 102
 103                         color.red = 0xae;
 104                         color.green = 0xaa;
 105                         color.blue = 0xae;
 106                         color.alpha = 0;
 107                         pixmap = WMCreateBlendedPixmapFromFile(WMWidgetScreen(panel->win), path, &color);
 108                         if (!pixmap) {
 109                                 WMSetLabelImage(panel->iconLabel, NULL);
 110                         } else {
 111                                 WMSetLabelImage(panel->iconLabel, pixmap);
 112                                 WMReleasePixmap(pixmap);
 113                         }
 114                 }
 115                 wfree(file);
 116                 wfree(path);
 117         }
 118 }
 119
 120 static void chooseIconCallback(WMWidget * self, void *clientData)
 121 {
 122         char *file;
 123         AppSettingsPanel *panel = (AppSettingsPanel *) clientData;
 124         int result;
 125
 126         panel->choosingIcon = 1;
 127
 128         WMSetButtonEnabled(panel->browseBtn, False);
 129
 130         result = wIconChooserDialog(panel->wwin->screen_ptr, &file,
 131                                     panel->editedIcon->wm_instance, panel->editedIcon->wm_class);
 132
 133         panel->choosingIcon = 0;
 134         if (!panel->destroyed) {
 135                 if (result) {
 136                         WMSetTextFieldText(panel->iconField, file);
 137                         wfree(file);
 138                         updateSettingsPanelIcon(panel);
 139                 }
 140
 141                 WMSetButtonEnabled(panel->browseBtn, True);
 142         } else {
 143                 /* kluge for the case, the user asked to close the panel before
 144                  * the icon chooser */
 145                 DestroyDockAppSettingsPanel(panel);
 146         }
 147 }
 148
 149 static void panelBtnCallback(WMWidget * self, void *data)
 150 {
 151         WMButton *btn = self;
 152         AppSettingsPanel *panel = (AppSettingsPanel *) data;
 153         char *text;
 154         int done = 1;
 155
 156         if (panel->okBtn == btn) {
 157                 text = WMGetTextFieldText(panel->iconField);
 158                 if (text[0] == 0) {
 159                         wfree(text);
 160                         text = NULL;
 161                 }
 162
 163                 if (!wIconChangeImageFile(panel->editedIcon->icon, text)) {
 164                         char *buf;
 165                         int len = strlen(text) + 64;
 166
 167                         buf = wmalloc(len);
 168                         snprintf(buf, len, _("Could not open specified icon file: %s"), text);
 169                         if (wMessageDialog(panel->wwin->screen_ptr, _("Error"), buf,
 170                                            _("OK"), _("Ignore"), NULL) == WAPRDefault) {
 171                                 if (text)
 172                                         wfree(text);
 173                                 wfree(buf);
 174                                 return;
 175                         }
 176                         wfree(buf);
 177                 } else {
 178                         WAppIcon *aicon = panel->editedIcon;
 179
 180                         if (aicon == aicon->icon->core->screen_ptr->clip_icon)
 181                                 wClipIconPaint(aicon);
 182                         else
 183                                 wAppIconPaint(aicon);
 184
 185                         wDefaultChangeIcon(panel->wwin->screen_ptr, aicon->wm_instance, aicon->wm_class, text);
 186                 }
 187                 if (text)
 188                         wfree(text);
 189
 190                 /* cannot free text from this, because it will be not be duplicated
 191                  * in updateCommand */
 192                 text = WMGetTextFieldText(panel->commandField);
 193                 if (text[0] == 0) {
 194                         wfree(text);
 195                         text = NULL;
 196                 }
 197                 updateCommand(panel->editedIcon, text);
 198 #ifdef XDND
 199                 /* cannot free text from this, because it will be not be duplicated
 200                  * in updateDNDCommand */
 201                 text = WMGetTextFieldText(panel->dndCommandField);
 202                 updateDNDCommand(panel->editedIcon, text);
 203 #endif
 204                 text = WMGetTextFieldText(panel->pasteCommandField);
 205                 updatePasteCommand(panel->editedIcon, text);
 206
 207                 panel->editedIcon->auto_launch = WMGetButtonSelected(panel->autoLaunchBtn);
 208
 209                 panel->editedIcon->lock = WMGetButtonSelected(panel->lockBtn);
 210         }
 211
 212         if (done)
 213                 DestroyDockAppSettingsPanel(panel);
 214 }
 215
 216 #define PWIDTH  295
 217 #define PHEIGHT 430
 218
 219 void ShowDockAppSettingsPanel(WAppIcon * aicon)
 220 {
 221         AppSettingsPanel *panel;
 222         WScreen *scr = aicon->icon->core->screen_ptr;
 223         Window parent;
 224         WMFont *font;
 225         int x, y;
 226         WMBox *vbox;
 227
 228         panel = wmalloc(sizeof(AppSettingsPanel));
 229
 230         panel->editedIcon = aicon;
 231
 232         aicon->panel = panel;
 233         aicon->editing = 1;
 234
 235         panel->win = WMCreateWindow(scr->wmscreen, "applicationSettings");
 236         WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
 237
 238         panel->iconLabel = WMCreateLabel(panel->win);
 239         WMResizeWidget(panel->iconLabel, 64, 64);
 240         WMMoveWidget(panel->iconLabel, 10, 10);
 241         WMSetLabelImagePosition(panel->iconLabel, WIPImageOnly);
 242
 243         panel->nameLabel = WMCreateLabel(panel->win);
 244         WMResizeWidget(panel->nameLabel, 190, 18);
 245         WMMoveWidget(panel->nameLabel, 80, 35);
 246         WMSetLabelTextAlignment(panel->nameLabel, WALeft);
 247         font = WMBoldSystemFontOfSize(scr->wmscreen, 14);
 248         WMSetLabelFont(panel->nameLabel, font);
 249         WMReleaseFont(font);
 250         if (aicon->wm_class && strcmp(aicon->wm_class, "DockApp") == 0)
 251                 WMSetLabelText(panel->nameLabel, aicon->wm_instance);
 252         else
 253                 WMSetLabelText(panel->nameLabel, aicon->wm_class);
 254
 255         vbox = WMCreateBox(panel->win);
 256         WMResizeWidget(vbox, PWIDTH - 20, PHEIGHT - 84 - 10);
 257         WMMoveWidget(vbox, 10, 84);
 258
 259         panel->autoLaunchBtn = WMCreateSwitchButton(vbox);
 260         WMAddBoxSubview(vbox, WMWidgetView(panel->autoLaunchBtn), False, True, 20, 20, 2);
 261         WMSetButtonText(panel->autoLaunchBtn, _("Start when Window Maker is started"));
 262         WMSetButtonSelected(panel->autoLaunchBtn, aicon->auto_launch);
 263
 264         panel->lockBtn = WMCreateSwitchButton(vbox);
 265         WMAddBoxSubview(vbox, WMWidgetView(panel->lockBtn), False, True, 20, 20, 5);
 266         WMSetButtonText(panel->lockBtn, _("Lock (prevent accidental removal)"));
 267         WMSetButtonSelected(panel->lockBtn, aicon->lock);
 268
 269         panel->commandFrame = WMCreateFrame(vbox);
 270         WMSetFrameTitle(panel->commandFrame, _("Application path and arguments"));
 271         WMAddBoxSubview(vbox, WMWidgetView(panel->commandFrame), False, True, 50, 50, 5);
 272
 273         panel->commandField = WMCreateTextField(panel->commandFrame);
 274         WMResizeWidget(panel->commandField, 256, 20);
 275         WMMoveWidget(panel->commandField, 10, 20);
 276         WMSetTextFieldText(panel->commandField, aicon->command);
 277
 278         WMMapSubwidgets(panel->commandFrame);
 279
 280         panel->pasteCommandFrame = WMCreateFrame(vbox);
 281         WMSetFrameTitle(panel->pasteCommandFrame, _("Command for middle-click launch"));
 282         WMAddBoxSubview(vbox, WMWidgetView(panel->pasteCommandFrame), False, True, 70, 70, 5);
 283
 284         panel->pasteCommandField = WMCreateTextField(panel->pasteCommandFrame);
 285         WMResizeWidget(panel->pasteCommandField, 256, 20);
 286         WMMoveWidget(panel->pasteCommandField, 10, 20);
 287
 288         panel->pasteCommandLabel = WMCreateLabel(panel->pasteCommandFrame);
 289         WMResizeWidget(panel->pasteCommandLabel, 256, 18);
 290         WMMoveWidget(panel->pasteCommandLabel, 10, 45);
 291
 292         WMSetTextFieldText(panel->pasteCommandField, aicon->paste_command);
 293         WMSetLabelText(panel->pasteCommandLabel, _("%s will be replaced with current selection"));
 294         WMMapSubwidgets(panel->pasteCommandFrame);
 295
 296         panel->dndCommandFrame = WMCreateFrame(vbox);
 297         WMSetFrameTitle(panel->dndCommandFrame, _("Command for files dropped with DND"));
 298         WMAddBoxSubview(vbox, WMWidgetView(panel->dndCommandFrame), False, True, 70, 70, 5);
 299
 300         panel->dndCommandField = WMCreateTextField(panel->dndCommandFrame);
 301         WMResizeWidget(panel->dndCommandField, 256, 20);
 302         WMMoveWidget(panel->dndCommandField, 10, 20);
 303
 304         panel->dndCommandLabel = WMCreateLabel(panel->dndCommandFrame);
 305         WMResizeWidget(panel->dndCommandLabel, 256, 18);
 306         WMMoveWidget(panel->dndCommandLabel, 10, 45);
 307 #ifdef XDND
 308         WMSetTextFieldText(panel->dndCommandField, aicon->dnd_command);
 309         WMSetLabelText(panel->dndCommandLabel, _("%d will be replaced with the file name"));
 310 #else
 311         WMSetTextFieldEditable(panel->dndCommandField, False);
 312         WMSetLabelText(panel->dndCommandLabel, _("DND support was not compiled in"));
 313 #endif
 314         WMMapSubwidgets(panel->dndCommandFrame);
 315
 316         panel->iconFrame = WMCreateFrame(vbox);
 317         WMSetFrameTitle(panel->iconFrame, _("Icon Image"));
 318         WMAddBoxSubview(vbox, WMWidgetView(panel->iconFrame), False, True, 50, 50, 10);
 319
 320         panel->iconField = WMCreateTextField(panel->iconFrame);
 321         WMResizeWidget(panel->iconField, 176, 20);
 322         WMMoveWidget(panel->iconField, 10, 20);
 323         WMSetTextFieldText(panel->iconField, wDefaultGetIconFile(aicon->wm_instance, aicon->wm_class, False));
 324
 325         panel->browseBtn = WMCreateCommandButton(panel->iconFrame);
 326         WMResizeWidget(panel->browseBtn, 70, 24);
 327         WMMoveWidget(panel->browseBtn, 195, 18);
 328         WMSetButtonText(panel->browseBtn, _("Browse..."));
 329         WMSetButtonAction(panel->browseBtn, chooseIconCallback, panel);
 330
 331         {
 332                 WMBox *hbox;
 333
 334                 hbox = WMCreateBox(vbox);
 335                 WMSetBoxHorizontal(hbox, True);
 336                 WMAddBoxSubview(vbox, WMWidgetView(hbox), False, True, 24, 24, 0);
 337
 338                 panel->okBtn = WMCreateCommandButton(hbox);
 339                 WMSetButtonText(panel->okBtn, _("OK"));
 340                 WMSetButtonAction(panel->okBtn, panelBtnCallback, panel);
 341                 WMAddBoxSubviewAtEnd(hbox, WMWidgetView(panel->okBtn), False, True, 80, 80, 0);
 342
 343                 panel->cancelBtn = WMCreateCommandButton(hbox);
 344                 WMSetButtonText(panel->cancelBtn, _("Cancel"));
 345                 WMSetButtonAction(panel->cancelBtn, panelBtnCallback, panel);
 346                 WMAddBoxSubviewAtEnd(hbox, WMWidgetView(panel->cancelBtn), False, True, 80, 80, 5);
 347
 348                 WMMapSubwidgets(hbox);
 349         }
 350
 351         WMRealizeWidget(panel->win);
 352         WMMapSubwidgets(panel->win);
 353         WMMapSubwidgets(vbox);
 354         WMMapSubwidgets(panel->iconFrame);
 355
 356         updateSettingsPanelIcon(panel);
 357
 358         parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, PWIDTH, PHEIGHT, 0, 0, 0);
 359         XSelectInput(dpy, parent, KeyPressMask | KeyReleaseMask);
 360
 361         XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
 362
 363         /*
 364          * make things relative to head
 365          */
 366         {
 367                 WMRect rect = wGetRectForHead(scr, wGetHeadForPointerLocation(scr));
 368
 369                 y = aicon->y_pos;
 370                 if (y < 0)
 371                         y = 0;
 372                 else if (y + PHEIGHT > rect.pos.y + rect.size.height)
 373                         y = rect.pos.y + rect.size.height - PHEIGHT - 30;
 374
 375                 if (aicon->dock && aicon->dock->type == WM_DOCK) {
 376                         if (aicon->dock->on_right_side)
 377                                 x = rect.pos.x + rect.size.width / 2;
 378                         else
 379                                 x = rect.pos.x + rect.size.width / 2 - PWIDTH - 2;
 380                 } else {
 381                         x = rect.pos.x + (rect.size.width - PWIDTH) / 2;
 382                 }
 383         }
 384
 385         panel->wwin = wManageInternalWindow(scr, parent, None,
 386                                             _("Docked Application Settings"), x, y, PWIDTH, PHEIGHT);
 387
 388         panel->wwin->client_leader = WMWidgetXID(panel->win);
 389
 390         panel->parent = parent;
 391
 392         WMMapWidget(panel->win);
 393
 394         wWindowMap(panel->wwin);
 395 }
 396
 397 void DestroyDockAppSettingsPanel(AppSettingsPanel * panel)
 398 {
 399         if (!panel->destroyed) {
 400                 XUnmapWindow(dpy, panel->wwin->client_win);
 401                 XReparentWindow(dpy, panel->wwin->client_win, panel->wwin->screen_ptr->root_win, 0, 0);
 402                 wUnmanageWindow(panel->wwin, False, False);
 403         }
 404
 405         panel->destroyed = 1;
 406
 407         /*
 408          * kluge. If we destroy the panel before the icon chooser is closed,
 409          * we will crash when it does close, trying to access something in the
 410          * destroyed panel. Could use wretain()/wrelease() in the panel,
 411          * but it is not working for some reason.
 412          */
 413         if (panel->choosingIcon)
 414                 return;
 415
 416         WMDestroyWidget(panel->win);
 417
 418         XDestroyWindow(dpy, panel->parent);
 419
 420         panel->editedIcon->panel = NULL;
 421
 422         panel->editedIcon->editing = 0;
 423
 424         wfree(panel);
 425 }