WINGs/Tests/wtest.c

   1 /*
   2  * WINGs test application
   3  */
   4
   5 #include "WINGs.h"
   6
   7 #include <stdio.h>
   8
   9
  10
  11 /*
  12  * You need to define this function to link any program to WINGs.
  13  * This will be called when the application will be terminated because
  14  * on a fatal error.
  15  */
  16 void
  17 wAbort()
  18 {
  19     exit(1);
  20 }
  21
  22
  23
  24
  25 Display *dpy;
  26
  27 int windowCount = 0;
  28
  29 void
  30 closeAction(WMWidget *self, void *data)
  31 {
  32     WMUnmapWidget(self);
  33     WMDestroyWidget(self);
  34     windowCount--;
  35     printf("window closed, window count = %d\n", windowCount);
  36     if (windowCount < 1)
  37         exit(0);
  38 }
  39
  40
  41 void
  42 testOpenFilePanel(WMScreen *scr)
  43 {
  44     WMOpenPanel *panel;
  45
  46     /* windowCount++; */
  47
  48     /* get the shared Open File panel */
  49     panel = WMGetOpenPanel(scr);
  50
  51     WMRunModalFilePanelForDirectory(panel, NULL, "/usr/local", NULL, NULL);
  52
  53     /* free the panel to save some memory. Not needed otherwise. */
  54     WMFreeFilePanel(WMGetOpenPanel(scr));
  55 }
  56
  57
  58 void
  59 testFontPanel(WMScreen *scr)
  60 {
  61     WMFontPanel *panel;
  62
  63     /*windowCount++;*/
  64
  65     panel = WMGetFontPanel(scr);
  66
  67     WMShowFontPanel(panel);
  68
  69 /*    WMFreeFontPanel(panel);*/
  70 }
  71
  72
  73
  74 void
  75 testFrame(WMScreen *scr)
  76 {
  77     WMWindow *win;
  78     WMFrame *frame;
  79     int i;
  80     static char* titles[] = {
  81         "AboveTop",
  82             "AtTop",
  83             "BelowTop",
  84             "AboveBottom",
  85             "AtBottom",
  86             "BelowBottom"
  87     };
  88     static WMTitlePosition pos[] = {
  89         WTPAboveTop,
  90         WTPAtTop,
  91         WTPBelowTop,
  92         WTPAboveBottom,
  93         WTPAtBottom,
  94         WTPBelowBottom
  95     };
  96
  97     windowCount++;
  98
  99     win = WMCreateWindow(scr, "testFrame");
 100     WMSetWindowTitle(win, "Frame");
 101     WMSetWindowCloseAction(win, closeAction, NULL);
 102     WMResizeWidget(win, 400, 300);
 103
 104     for (i = 0; i < 6; i++) {
 105         frame = WMCreateFrame(win);
 106         WMMoveWidget(frame, 8+(i%3)*130, 8+(i/3)*130);
 107         WMResizeWidget(frame, 120, 120);
 108         WMSetFrameTitle(frame, titles[i]);
 109         WMSetFrameTitlePosition(frame, pos[i]);
 110     }
 111
 112     WMRealizeWidget(win);
 113     WMMapSubwidgets(win);
 114     WMMapWidget(win);
 115
 116 }
 117
 118
 119 static void
 120 singleClick(WMWidget *self, void *data)
 121 {
 122 }
 123
 124
 125 static void
 126 doubleClick(WMWidget *self, void *data)
 127 {
 128     WMLabel *label = (WMLabel*)data;
 129     WMList *lPtr = (WMList*)self;
 130     char buf[255];
 131
 132     WMSelectAllListItems(lPtr);
 133
 134     //sprintf(buf, "Selected items: %d",
 135     //        WMGetArrayItemCount(WMGetListSelectedItems(lPtr)));;
 136     //WMSetLabelText(label, buf);
 137 }
 138
 139
 140 static void
 141 listSelectionObserver(void *observer, WMNotification *notification)
 142 {
 143     WMLabel *label = (WMLabel*)observer;
 144     WMList *lPtr = (WMList*)WMGetNotificationObject(notification);
 145     char buf[255];
 146
 147     sprintf(buf, "Selected items: %d",
 148             WMGetArrayItemCount(WMGetListSelectedItems(lPtr)));;
 149     WMSetLabelText(label, buf);
 150 }
 151
 152
 153 void
 154 testList(WMScreen *scr)
 155 {
 156     WMWindow *win;
 157     WMList *list;
 158     WMList *mlist;
 159     WMLabel *label;
 160     WMLabel *mlabel;
 161     WMLabel *title;
 162     WMLabel *mtitle;
 163     char text[100];
 164     int i;
 165
 166     windowCount++;
 167
 168     win = WMCreateWindow(scr, "testList");
 169     WMResizeWidget(win, 370, 250);
 170     WMSetWindowTitle(win, "List");
 171     WMSetWindowCloseAction(win, closeAction, NULL);
 172
 173     title = WMCreateLabel(win);
 174     WMResizeWidget(title, 150, 20);
 175     WMMoveWidget(title, 10, 10);
 176     WMSetLabelRelief(title, WRRidge);
 177     WMSetLabelText(title, "Single selection list");
 178
 179     mtitle = WMCreateLabel(win);
 180     WMResizeWidget(mtitle, 150, 20);
 181     WMMoveWidget(mtitle, 210, 10);
 182     WMSetLabelRelief(mtitle, WRRidge);
 183     WMSetLabelText(mtitle, "Multiple selection list");
 184
 185     list = WMCreateList(win);
 186     //WMSetListAllowEmptySelection(list, True);
 187     WMMoveWidget(list, 10, 40);
 188     for (i=0; i<50; i++) {
 189         sprintf(text, "Item %i", i);
 190         WMAddListItem(list, text);
 191     }
 192     mlist = WMCreateList(win);
 193     WMSetListAllowMultipleSelection(mlist, True);
 194     //WMSetListAllowEmptySelection(mlist, True);
 195     WMMoveWidget(mlist, 210, 40);
 196     for (i=0; i<135; i++) {
 197         sprintf(text, "Item %i", i);
 198         WMAddListItem(mlist, text);
 199     }
 200
 201     label = WMCreateLabel(win);
 202     WMResizeWidget(label, 150, 40);
 203     WMMoveWidget(label, 10, 200);
 204     WMSetLabelRelief(label, WRRidge);
 205     WMSetLabelText(label, "Selected items: 0");
 206
 207     mlabel = WMCreateLabel(win);
 208     WMResizeWidget(mlabel, 150, 40);
 209     WMMoveWidget(mlabel, 210, 200);
 210     WMSetLabelRelief(mlabel, WRRidge);
 211     WMSetLabelText(mlabel, "Selected items: 0");
 212
 213     WMSetListAction(list, singleClick, label);
 214     WMSetListDoubleAction(list, doubleClick, label);
 215     WMSetListAction(mlist, singleClick, mlabel);
 216     WMSetListDoubleAction(mlist, doubleClick, mlabel);
 217
 218     WMAddNotificationObserver(listSelectionObserver, label,
 219                               WMListSelectionDidChangeNotification, list);
 220     WMAddNotificationObserver(listSelectionObserver, mlabel,
 221                               WMListSelectionDidChangeNotification, mlist);
 222
 223
 224     WMRealizeWidget(win);
 225     WMMapSubwidgets(win);
 226     WMMapWidget(win);
 227 }
 228
 229
 230 void
 231 testButton(WMScreen *scr)
 232 {
 233     WMWindow *win;
 234     int i;
 235     char *types[] = {
 236         "MomentaryPush",
 237             "PushOnPushOff",
 238             "Toggle",
 239             "Switch",
 240             "Radio",
 241             "MomentaryChange",
 242             "OnOff",
 243             "MomentaryLigh"
 244     };
 245
 246     windowCount++;
 247
 248     win = WMCreateWindow(scr, "testButton");
 249     WMResizeWidget(win, 300, 300);
 250     WMSetWindowTitle(win, "Buttons");
 251
 252     WMSetWindowCloseAction(win, closeAction, NULL);
 253
 254     for (i = 1; i < 9; i++) {
 255         WMButton *b;
 256         b = WMCreateButton(win, i);
 257         WMResizeWidget(b, 150, 24);
 258         WMMoveWidget(b, 20, i*30);
 259         WMSetButtonText(b, types[i-1]);
 260     }
 261
 262     WMRealizeWidget(win);
 263     WMMapSubwidgets(win);
 264     WMMapWidget(win);
 265 }
 266
 267
 268 void
 269 testGradientButtons(WMScreen *scr)
 270 {
 271     WMWindow *win;
 272     WMButton *btn;
 273     WMPixmap *pix1, *pix2;
 274     RImage *back;
 275     RColor light, dark;
 276     WMColor *color, *altColor;
 277
 278     windowCount++;
 279
 280     /* creates the top-level window */
 281     win = WMCreateWindow(scr, "testGradientButtons");
 282     WMSetWindowTitle(win, "Gradiented Button Demo");
 283     WMResizeWidget(win, 300, 200);
 284
 285     light.red = 0x90;
 286     light.green = 0x85;
 287     light.blue = 0x90;
 288     dark.red = 0x35;
 289     dark.green = 0x30;
 290     dark.blue = 0x35;
 291
 292     color = WMCreateRGBColor(scr, 0x5900, 0x5100, 0x5900, True);
 293     WMSetWidgetBackgroundColor(win, color);
 294     WMReleaseColor(color);
 295
 296     back = RRenderGradient(60, 24, &dark, &light, RGRD_DIAGONAL);
 297     RBevelImage(back, RBEV_RAISED2);
 298     pix1 = WMCreatePixmapFromRImage(scr, back, 0);
 299     RDestroyImage(back);
 300
 301     back = RRenderGradient(60, 24, &dark, &light, RGRD_DIAGONAL);
 302     RBevelImage(back, RBEV_SUNKEN);
 303     pix2 = WMCreatePixmapFromRImage(scr, back, 0);
 304     RDestroyImage(back);
 305
 306     color = WMWhiteColor(scr);
 307     altColor = WMCreateNamedColor(scr, "red", True);
 308
 309     btn = WMCreateButton(win, WBTMomentaryChange);
 310     WMResizeWidget(btn, 60, 24);
 311     WMMoveWidget(btn, 20, 100);
 312     WMSetButtonBordered(btn, False);
 313     WMSetButtonImagePosition(btn, WIPOverlaps);
 314     WMSetButtonImage(btn, pix1);
 315     WMSetButtonAltImage(btn, pix2);
 316     WMSetButtonText(btn, "Cool");
 317     WMSetButtonTextColor(btn, color);
 318     WMSetButtonAltTextColor(btn, altColor);
 319
 320     WMSetBalloonTextForView("This is a cool button", WMWidgetView(btn));
 321
 322     btn = WMCreateButton(win, WBTMomentaryChange);
 323     WMResizeWidget(btn, 60, 24);
 324     WMMoveWidget(btn, 90, 100);
 325     WMSetButtonBordered(btn, False);
 326     WMSetButtonImagePosition(btn, WIPOverlaps);
 327     WMSetButtonImage(btn, pix1);
 328     WMSetButtonAltImage(btn, pix2);
 329     WMSetButtonText(btn, "Button");
 330     WMSetButtonTextColor(btn, color);
 331
 332     WMSetBalloonTextForView("Este é outro balão.", WMWidgetView(btn));
 333
 334     WMReleaseColor(color);
 335     color = WMCreateNamedColor(scr, "orange", True);
 336
 337     btn = WMCreateButton(win, WBTMomentaryChange);
 338     WMResizeWidget(btn, 60, 24);
 339     WMMoveWidget(btn, 160, 100);
 340     WMSetButtonBordered(btn, False);
 341     WMSetButtonImagePosition(btn, WIPOverlaps);
 342     WMSetButtonImage(btn, pix1);
 343     WMSetButtonAltImage(btn, pix2);
 344     WMSetButtonText(btn, "Test");
 345     WMSetButtonTextColor(btn, color);
 346
 347     WMSetBalloonTextForView("This is yet another button.\nBut the balloon has 3 lines.\nYay!",
 348                             WMWidgetView(btn));
 349
 350     WMReleaseColor(color);
 351     WMReleaseColor(altColor);
 352
 353     WMRealizeWidget(win);
 354     WMMapSubwidgets(win);
 355     WMMapWidget(win);
 356 }
 357
 358
 359 void
 360 testScrollView(WMScreen *scr)
 361 {
 362     WMWindow *win;
 363     WMScrollView *sview;
 364     WMFrame *f;
 365     WMLabel *l;
 366     char buffer[128];
 367     int i;
 368
 369     windowCount++;
 370
 371     /* creates the top-level window */
 372     win = WMCreateWindow(scr, "testScroll");
 373     WMSetWindowTitle(win, "Scrollable View");
 374
 375     WMSetWindowCloseAction(win, closeAction, NULL);
 376
 377     /* set the window size */
 378     WMResizeWidget(win, 300, 300);
 379
 380     /* creates a scrollable view inside the top-level window */
 381     sview = WMCreateScrollView(win);
 382     WMResizeWidget(sview, 200, 200);
 383     WMMoveWidget(sview, 30, 30);
 384     WMSetScrollViewRelief(sview, WRSunken);
 385     WMSetScrollViewHasVerticalScroller(sview, True);
 386     WMSetScrollViewHasHorizontalScroller(sview, True);
 387
 388     /* create a frame with a bunch of labels */
 389     f = WMCreateFrame(win);
 390     WMResizeWidget(f, 400, 400);
 391     WMSetFrameRelief(f, WRFlat);
 392
 393     for (i=0; i<20; i++) {
 394         l = WMCreateLabel(f);
 395         WMResizeWidget(l, 50, 18);
 396         WMMoveWidget(l, 10, 20*i);
 397         sprintf(buffer, "Label %i", i);
 398         WMSetLabelText(l, buffer);
 399         WMSetLabelRelief(l, WRSimple);
 400     }
 401     WMMapSubwidgets(f);
 402     WMMapWidget(f);
 403
 404     WMSetScrollViewContentView(sview, WMWidgetView(f));
 405
 406     /* make the windows of the widgets be actually created */
 407     WMRealizeWidget(win);
 408
 409     /* Map all child widgets of the top-level be mapped.
 410      * You must call this for each container widget (like frames),
 411      * even if they are childs of the top-level window.
 412      */
 413     WMMapSubwidgets(win);
 414
 415     /* map the top-level window */
 416     WMMapWidget(win);
 417 }
 418
 419
 420 void
 421 testColorWell(WMScreen *scr)
 422 {
 423     WMWindow *win;
 424     WMColorWell *well1, *well2;
 425
 426     windowCount++;
 427
 428     win = WMCreateWindow(scr, "testColor");
 429     WMResizeWidget(win, 300, 300);
 430     WMSetWindowCloseAction(win, closeAction, NULL);
 431
 432     well1 = WMCreateColorWell(win);
 433     WMResizeWidget(well1, 60, 40);
 434     WMMoveWidget(well1, 100, 100);
 435     WMSetColorWellColor(well1, WMCreateRGBColor(scr, 0x8888, 0, 0x1111, True));
 436     well2 = WMCreateColorWell(win);
 437     WMResizeWidget(well2, 60, 40);
 438     WMMoveWidget(well2, 200, 100);
 439     WMSetColorWellColor(well2, WMCreateRGBColor(scr, 0, 0, 0x8888, True));
 440
 441     WMRealizeWidget(win);
 442     WMMapSubwidgets(win);
 443     WMMapWidget(win);
 444 }
 445
 446 void
 447 sliderCallback(WMWidget *w, void *data)
 448 {
 449     printf("SLIDER == %i\n", WMGetSliderValue(w));
 450 }
 451
 452
 453 void
 454 testSlider(WMScreen *scr)
 455 {
 456     WMWindow *win;
 457     WMSlider *s;
 458
 459     windowCount++;
 460
 461     win = WMCreateWindow(scr, "testSlider");
 462     WMResizeWidget(win, 300, 300);
 463     WMSetWindowTitle(win, "Sliders");
 464
 465     WMSetWindowCloseAction(win, closeAction, NULL);
 466
 467     s = WMCreateSlider(win);
 468     WMResizeWidget(s, 16, 100);
 469     WMMoveWidget(s, 100, 100);
 470     WMSetSliderKnobThickness(s, 8);
 471     WMSetSliderContinuous(s, False);
 472     WMSetSliderAction(s, sliderCallback, s);
 473
 474     s = WMCreateSlider(win);
 475     WMResizeWidget(s, 100, 16);
 476     WMMoveWidget(s, 100, 10);
 477     WMSetSliderKnobThickness(s, 8);
 478
 479     WMRealizeWidget(win);
 480     WMMapSubwidgets(win);
 481     WMMapWidget(win);
 482 }
 483
 484 void
 485 testTextField(WMScreen *scr)
 486 {
 487     WMWindow *win;
 488     WMTextField *field, *field2;
 489
 490     windowCount++;
 491
 492     win = WMCreateWindow(scr, "testTextField");
 493     WMResizeWidget(win, 400, 300);
 494
 495     WMSetWindowCloseAction(win, closeAction, NULL);
 496
 497     field = WMCreateTextField(win);
 498     WMResizeWidget(field, 200, 20);
 499     WMMoveWidget(field, 20, 20);
 500
 501     field2 = WMCreateTextField(win);
 502     WMResizeWidget(field2, 200, 20);
 503     WMMoveWidget(field2, 20, 50);
 504     WMSetTextFieldAlignment(field2, WARight);
 505
 506     WMRealizeWidget(win);
 507     WMMapSubwidgets(win);
 508     WMMapWidget(win);
 509
 510 }
 511
 512 void
 513 testText(WMScreen *scr)
 514 {
 515     WMWindow *win;
 516     WMText *text;
 517         FILE *file = fopen("../README", "r");
 518
 519     windowCount++;
 520
 521     win = WMCreateWindow(scr, "testText");
 522     WMResizeWidget(win, 500, 300);
 523
 524     WMSetWindowCloseAction(win, closeAction, NULL);
 525
 526     text = WMCreateText(win);
 527     WMResizeWidget(text, 480, 280);
 528     WMMoveWidget(text, 10, 10);
 529     WMSetTextHasVerticalScroller(text, True);
 530         WMSetTextEditable(text, False);
 531
 532         if(file) {
 533         char buf[1024];
 534
 535                 WMFreezeText(text);
 536                 while(fgets(buf, 1023, file))
 537                         WMAppendTextStream(text, buf);
 538
 539                 fclose(file);
 540                 WMThawText(text);
 541                 WMRefreshText(text, 0, 0);
 542         } else {
 543                 WMAppendTextStream(text, "<HTML><i>Where's</i> the <b>README</b>?");
 544         }
 545
 546     WMRealizeWidget(win);
 547     WMMapSubwidgets(win);
 548     WMMapWidget(win);
 549
 550 }
 551
 552
 553 void
 554 testProgressIndicator(WMScreen *scr)
 555 {
 556     WMWindow *win;
 557     WMProgressIndicator *pPtr;
 558
 559     windowCount++;
 560
 561     win = WMCreateWindow(scr, "testProgressIndicator");
 562     WMResizeWidget(win, 292, 32);
 563
 564     WMSetWindowCloseAction(win, closeAction, NULL);
 565
 566     pPtr = WMCreateProgressIndicator(win);
 567     WMMoveWidget(pPtr, 8, 8);
 568     WMSetProgressIndicatorValue(pPtr, 75);
 569
 570     WMRealizeWidget(win);
 571     WMMapSubwidgets(win);
 572     WMMapWidget(win);
 573
 574 }
 575
 576
 577 void
 578 testPullDown(WMScreen *scr)
 579 {
 580     WMWindow *win;
 581     WMPopUpButton *pop, *pop2;
 582
 583     windowCount++;
 584
 585     win = WMCreateWindow(scr, "pullDown");
 586     WMResizeWidget(win, 400, 300);
 587
 588     WMSetWindowCloseAction(win, closeAction, NULL);
 589
 590     pop = WMCreatePopUpButton(win);
 591     WMResizeWidget(pop, 100, 20);
 592     WMMoveWidget(pop, 50, 60);
 593     WMSetPopUpButtonPullsDown(pop, True);
 594     WMSetPopUpButtonText(pop, "Commands");
 595     WMAddPopUpButtonItem(pop, "Add");
 596     WMAddPopUpButtonItem(pop, "Remove");
 597     WMAddPopUpButtonItem(pop, "Check");
 598     WMAddPopUpButtonItem(pop, "Eat");
 599
 600     pop2 = WMCreatePopUpButton(win);
 601     WMResizeWidget(pop2, 100, 20);
 602     WMMoveWidget(pop2, 200, 60);
 603     WMSetPopUpButtonText(pop2, "Select");
 604     WMAddPopUpButtonItem(pop2, "Apples");
 605     WMAddPopUpButtonItem(pop2, "Bananas");
 606     WMAddPopUpButtonItem(pop2, "Strawberries");
 607     WMAddPopUpButtonItem(pop2, "Blueberries");
 608
 609     WMRealizeWidget(win);
 610     WMMapSubwidgets(win);
 611     WMMapWidget(win);
 612
 613 }
 614
 615
 616 void
 617 testTabView(WMScreen *scr)
 618 {
 619     WMWindow *win;
 620     WMTabView *tabv;
 621     WMTabViewItem *tab;
 622     WMFrame *frame;
 623     WMLabel *label;
 624
 625     windowCount++;
 626
 627     win = WMCreateWindow(scr, "testTabs");
 628     WMResizeWidget(win, 400, 300);
 629
 630     WMSetWindowCloseAction(win, closeAction, NULL);
 631
 632     tabv = WMCreateTabView(win);
 633     WMMoveWidget(tabv, 50, 50);
 634     WMResizeWidget(tabv, 300, 200);
 635
 636     frame = WMCreateFrame(win);
 637     WMSetFrameRelief(frame, WRFlat);
 638     label = WMCreateLabel(frame);
 639     WMResizeWidget(label, 100, 100);
 640     WMSetLabelText(label, "Label 1");
 641     WMMapWidget(label);
 642
 643
 644     tab = WMCreateTabViewItemWithIdentifier(0);
 645     WMSetTabViewItemView(tab, WMWidgetView(frame));
 646     WMAddItemInTabView(tabv, tab);
 647     WMSetTabViewItemLabel(tab, "Instances");
 648
 649     frame = WMCreateFrame(win);
 650     WMSetFrameRelief(frame, WRFlat);
 651     label = WMCreateLabel(frame);
 652     WMResizeWidget(label, 40, 50);
 653     WMSetLabelText(label, "Label 2");
 654     WMMapWidget(label);
 655
 656
 657     tab = WMCreateTabViewItemWithIdentifier(0);
 658     WMSetTabViewItemView(tab, WMWidgetView(frame));
 659     WMAddItemInTabView(tabv, tab);
 660     WMSetTabViewItemLabel(tab, "Classes");
 661
 662
 663     frame = WMCreateFrame(win);
 664     WMSetFrameRelief(frame, WRFlat);
 665     label = WMCreateLabel(frame);
 666     WMResizeWidget(label, 100, 100);
 667     WMMoveWidget(label, 60, 40);
 668     WMSetLabelText(label, "Label 3");
 669     WMMapWidget(label);
 670
 671     tab = WMCreateTabViewItemWithIdentifier(0);
 672     WMSetTabViewItemView(tab, WMWidgetView(frame));
 673     WMAddItemInTabView(tabv, tab);
 674     WMSetTabViewItemLabel(tab, "Something");
 675
 676
 677     frame = WMCreateFrame(win);
 678     WMSetFrameRelief(frame, WRFlat);
 679     label = WMCreateLabel(frame);
 680     WMResizeWidget(label, 100, 100);
 681     WMMoveWidget(label, 160, 40);
 682     WMSetLabelText(label, "Label 4");
 683     WMMapWidget(label);
 684
 685     tab = WMCreateTabViewItemWithIdentifier(0);
 686     WMSetTabViewItemView(tab, WMWidgetView(frame));
 687     WMAddItemInTabView(tabv, tab);
 688     WMSetTabViewItemLabel(tab, "Bla!");
 689
 690
 691
 692     frame = WMCreateFrame(win);
 693     WMSetFrameRelief(frame, WRFlat);
 694     label = WMCreateLabel(frame);
 695     WMResizeWidget(label, 100, 100);
 696     WMMoveWidget(label, 160, 40);
 697     WMSetLabelText(label, "Label fjweqklrj qwl");
 698     WMMapWidget(label);
 699     tab = WMCreateTabViewItemWithIdentifier(0);
 700     WMSetTabViewItemView(tab, WMWidgetView(frame));
 701     WMAddItemInTabView(tabv, tab);
 702     WMSetTabViewItemLabel(tab, "Weee!");
 703
 704
 705     WMRealizeWidget(win);
 706     WMMapSubwidgets(win);
 707     WMMapWidget(win);
 708 }
 709
 710
 711 void
 712 splitViewConstrainProc(WMSplitView *sPtr, int indView,
 713                        int *minSize, int *maxSize)
 714 {
 715     switch (indView) {
 716     case 0:
 717         *minSize = 20;
 718         break;
 719     case 1:
 720         *minSize = 40;
 721         *maxSize = 80;
 722         break;
 723     case 2:
 724         *maxSize = 60;
 725         break;
 726     default:
 727         break;
 728     }
 729 }
 730
 731
 732 static void
 733 resizeSplitView(XEvent *event, void *data)
 734 {
 735     WMSplitView *sPtr = (WMSplitView*)data;
 736
 737     if (event->type == ConfigureNotify) {
 738         int width = event->xconfigure.width - 10;
 739
 740         if (width < WMGetSplitViewDividerThickness(sPtr))
 741             width = WMGetSplitViewDividerThickness(sPtr);
 742
 743         if (width != WMWidgetWidth(sPtr) ||
 744             event->xconfigure.height != WMWidgetHeight(sPtr))
 745             WMResizeWidget(sPtr, width, event->xconfigure.height - 55);
 746     }
 747 }
 748
 749 void
 750 appendSubviewButtonAction(WMWidget *self, void *data)
 751 {
 752     WMSplitView *sPtr = (WMSplitView*)data;
 753     char buf[64];
 754     WMLabel *label = WMCreateLabel(sPtr);
 755
 756     sprintf(buf, "Subview %d", WMGetSplitViewSubviewsCount(sPtr) + 1);
 757     WMSetLabelText(label, buf);
 758     WMSetLabelRelief(label, WRSunken);
 759     WMAddSplitViewSubview(sPtr, WMWidgetView(label));
 760     WMRealizeWidget(label);
 761     WMMapWidget(label);
 762 }
 763
 764 void
 765 removeSubviewButtonAction(WMWidget *self, void *data)
 766 {
 767     WMSplitView *sPtr = (WMSplitView*)data;
 768     int count = WMGetSplitViewSubviewsCount(sPtr);
 769
 770     if (count > 2) {
 771         WMView *view = WMGetSplitViewSubviewAt(sPtr, count-1);
 772         WMDestroyWidget(WMWidgetOfView(view));
 773         WMRemoveSplitViewSubviewAt(sPtr, count-1);
 774     }
 775 }
 776
 777 void
 778 orientationButtonAction(WMWidget *self, void *data)
 779 {
 780     WMSplitView *sPtr = (WMSplitView*)data;
 781     WMSetSplitViewVertical(sPtr, !WMGetSplitViewVertical(sPtr));
 782 }
 783
 784 void
 785 adjustSubviewsButtonAction(WMWidget *self, void *data)
 786 {
 787     WMAdjustSplitViewSubviews((WMSplitView*)data);
 788 }
 789
 790 void
 791 testSplitView(WMScreen *scr)
 792 {
 793     WMWindow *win;
 794     WMSplitView *splitv1, *splitv2;
 795     WMFrame *frame;
 796     WMLabel *label;
 797     WMButton *button;
 798
 799     windowCount++;
 800
 801     win = WMCreateWindow(scr, "testTabs");
 802     WMResizeWidget(win, 300, 400);
 803     WMSetWindowCloseAction(win, closeAction, NULL);
 804
 805     frame = WMCreateFrame(win);
 806     WMSetFrameRelief(frame, WRSunken);
 807     WMMoveWidget(frame, 5, 5);
 808     WMResizeWidget(frame, 290, 40);
 809
 810     splitv1 = WMCreateSplitView(win);
 811     WMMoveWidget(splitv1, 5, 50);
 812     WMResizeWidget(splitv1, 290, 345);
 813     WMSetSplitViewConstrainProc(splitv1, splitViewConstrainProc);
 814     WMCreateEventHandler(WMWidgetView(win), StructureNotifyMask,
 815                          resizeSplitView, splitv1);
 816
 817     button = WMCreateCommandButton(frame);
 818     WMSetButtonText(button, "+");
 819     WMSetButtonAction(button, appendSubviewButtonAction, splitv1);
 820     WMMoveWidget(button, 10, 8);
 821     WMMapWidget(button);
 822
 823     button = WMCreateCommandButton(frame);
 824     WMSetButtonText(button, "-");
 825     WMSetButtonAction(button, removeSubviewButtonAction, splitv1);
 826     WMMoveWidget(button, 80, 8);
 827     WMMapWidget(button);
 828
 829     button = WMCreateCommandButton(frame);
 830     WMSetButtonText(button, "=");
 831     WMMoveWidget(button, 150, 8);
 832     WMSetButtonAction(button, adjustSubviewsButtonAction, splitv1);
 833     WMMapWidget(button);
 834
 835     button = WMCreateCommandButton(frame);
 836     WMSetButtonText(button, "#");
 837     WMMoveWidget(button, 220, 8);
 838     WMSetButtonAction(button, orientationButtonAction, splitv1);
 839     WMMapWidget(button);
 840
 841     label = WMCreateLabel(splitv1);
 842     WMSetLabelText(label, "Subview 1");
 843     WMSetLabelRelief(label, WRSunken);
 844     WMMapWidget(label);
 845     WMAddSplitViewSubview(splitv1, WMWidgetView(label));
 846
 847     splitv2 = WMCreateSplitView(splitv1);
 848     WMResizeWidget(splitv2, 150, 150);
 849     WMSetSplitViewVertical(splitv2, True);
 850
 851     label = WMCreateLabel(splitv2);
 852     WMSetLabelText(label, "Subview 2.1");
 853     WMSetLabelRelief(label, WRSunken);
 854     WMMapWidget(label);
 855     WMAddSplitViewSubview(splitv2, WMWidgetView(label));
 856
 857     label = WMCreateLabel(splitv2);
 858     WMSetLabelText(label, "Subview 2.2");
 859     WMSetLabelRelief(label, WRSunken);
 860     WMMapWidget(label);
 861     WMAddSplitViewSubview(splitv2, WMWidgetView(label));
 862
 863     label = WMCreateLabel(splitv2);
 864     WMSetLabelText(label, "Subview 2.3");
 865     WMSetLabelRelief(label, WRSunken);
 866     WMMapWidget(label);
 867     WMAddSplitViewSubview(splitv2, WMWidgetView(label));
 868
 869     WMMapWidget(splitv2);
 870     WMAddSplitViewSubview(splitv1, WMWidgetView(splitv2));
 871
 872     WMRealizeWidget(win);
 873     WMMapSubwidgets(win);
 874     WMMapWidget(win);
 875 }
 876
 877
 878 /*******************************************************************/
 879
 880 #include <sys/types.h>
 881 #include <dirent.h>
 882 #include <string.h>
 883
 884
 885 typedef struct {
 886     int x, y;
 887     Bool mouseDown;
 888     char *filename;
 889 } DNDStuff;
 890
 891 WMPixmap*
 892 getImage(WMScreen *scr, char *file)
 893 {
 894     char buffer[1000];
 895     WMPixmap *pix;
 896
 897     sprintf(buffer, "../../WindowMaker/Icons/%s", file);
 898     pix = WMCreatePixmapFromFile(scr, buffer);
 899
 900     return pix;
 901 }
 902
 903
 904
 905
 906 static void
 907 iconMouseStuff(XEvent *event, void *cdata)
 908 {
 909     WMLabel *label = (WMLabel*)cdata;
 910     DNDStuff *stuff = WMGetHangedData(label);
 911     WMPoint where;
 912
 913     switch (event->type) {
 914      case ButtonPress:
 915         stuff->x = event->xbutton.x;
 916         stuff->y = event->xbutton.y;
 917         stuff->mouseDown = True;
 918         break;
 919      case ButtonRelease:
 920         stuff->mouseDown = False;
 921         break;
 922      case MotionNotify:
 923         if (!stuff->mouseDown)
 924             break;
 925
 926         if (abs(stuff->x - event->xmotion.x)>4
 927             || abs(stuff->y - event->xmotion.y)>4) {
 928
 929             where = WMGetViewScreenPosition(WMWidgetView(label));
 930
 931             WMDragImageFromView(WMWidgetView(label),
 932                                 WMGetLabelImage(label),
 933                                 NULL, /* XXX */
 934                                 where,
 935                                 wmksize(stuff->x, stuff->y),
 936                                 event, True);
 937         }
 938         break;
 939     }
 940 }
 941
 942
 943 static void
 944 endedDragImage(WMView *self, WMPixmap *image, WMPoint point, Bool deposited)
 945 {
 946     DNDStuff *stuff = WMGetHangedData(WMWidgetOfView(self));
 947
 948     if (deposited) {
 949         WMDestroyWidget(WMWidgetOfView(self));
 950     }
 951
 952     stuff->mouseDown = False;
 953 }
 954
 955
 956 static WMData*
 957 fetchDragData(WMView *self, char *type)
 958 {
 959     DNDStuff *stuff = WMGetHangedData(WMWidgetOfView(self));
 960
 961     return WMCreateDataWithBytes(stuff->filename, strlen(stuff->filename)+1);
 962 }
 963
 964
 965 WMDragSourceProcs dragSourceProcs = {
 966     NULL,
 967     NULL,
 968     endedDragImage,
 969     fetchDragData
 970 };
 971
 972
 973 /************************/
 974
 975
 976 unsigned
 977 draggingEntered(WMView *self, WMDraggingInfo *info)
 978 {
 979     return WDOperationCopy;
 980 }
 981
 982
 983 unsigned
 984 draggingUpdated(WMView *self, WMDraggingInfo *info)
 985 {
 986     return WDOperationCopy;
 987 }
 988
 989 /*
 990  void (*draggingExited)(WMView *self, WMDraggingInfo *info);
 991  */
 992 char*
 993 prepareForDragOperation(WMView *self, WMDraggingInfo *info)
 994 {
 995     return "application/X-WINGs-Bla";
 996 }
 997
 998
 999 WMLabel* makeDraggableLabel(WMWidget *w, char *file, int x, int y);
1000
1001 Bool
1002 performDragOperation(WMView *self, WMDraggingInfo *info, WMData *data)
1003 {
1004     char *file = (char*)WMDataBytes(data);
1005     WMPoint pos;
1006
1007     pos = WMGetDraggingInfoImageLocation(info);
1008
1009     if (file!=NULL) {
1010         WMLabel *label;
1011         WMPoint pos2 = WMGetViewScreenPosition(self);
1012
1013
1014         label = makeDraggableLabel(WMWidgetOfView(self), file,
1015                                    pos.x-pos2.x, pos.y-pos2.y);
1016         WMRealizeWidget(label);
1017         WMMapWidget(label);
1018     }
1019
1020
1021     return True;
1022 }
1023
1024
1025 void
1026 concludeDragOperation(WMView *self, WMDraggingInfo *info)
1027 {
1028
1029 }
1030
1031
1032
1033 WMDragDestinationProcs dragDestProcs = {
1034     draggingEntered,
1035         draggingUpdated,
1036         NULL,
1037         prepareForDragOperation,
1038         performDragOperation,
1039         concludeDragOperation
1040 };
1041
1042
1043
1044
1045 WMLabel*
1046 makeDraggableLabel(WMWidget *w, char *file, int x, int y)
1047 {
1048     DNDStuff *stuff;
1049     WMLabel *label;
1050     WMPixmap *image = getImage(WMWidgetScreen(w), file);
1051
1052     stuff = wmalloc(sizeof(DNDStuff));
1053     stuff->mouseDown = False;
1054
1055     stuff->filename = wstrdup(file);
1056
1057     label = WMCreateLabel(w);
1058     WMResizeWidget(label, 48, 48);
1059     WMMoveWidget(label, x, y);
1060
1061     WMSetViewDragSourceProcs(WMWidgetView(label), &dragSourceProcs);
1062
1063     WMHangData(label, stuff);
1064
1065     WMCreateEventHandler(WMWidgetView(label),
1066                          ButtonPressMask|ButtonReleaseMask|ButtonMotionMask,
1067                          iconMouseStuff, label);
1068
1069
1070     if (image != NULL) {
1071         WMSetLabelImagePosition(label, WIPImageOnly);
1072         WMSetLabelImage(label, image);
1073         WMReleasePixmap(image);
1074     } else puts(file);
1075
1076     return label;
1077 }
1078
1079
1080
1081 void
1082 testDragAndDrop(WMScreen *scr)
1083 {
1084     WMWindow *win;
1085     WMFrame *frame;
1086     WMLabel *label;
1087     int i, j;
1088     DIR *dir;
1089     struct dirent *ent;
1090     char *types[] = {
1091         "application/X-WINGs-Bla",
1092         NULL
1093     };
1094
1095     windowCount++;
1096
1097     win = WMCreateWindow(scr, "dragDrop");
1098     WMResizeWidget(win, 300, 300);
1099     WMSetWindowCloseAction(win, closeAction, NULL);
1100     WMSetWindowTitle(win, "Drag and Drop");
1101
1102
1103     frame = WMCreateFrame(win);
1104     WMSetFrameRelief(frame, WRSunken);
1105     WMResizeWidget(frame, 250, 250);
1106     WMMoveWidget(frame, 25, 25);
1107
1108     WMRegisterViewForDraggedTypes(WMWidgetView(frame), types);
1109     WMSetViewDragDestinationProcs(WMWidgetView(frame), &dragDestProcs);
1110
1111     dir = opendir("../../WindowMaker/Icons");
1112     if (!dir) {
1113         perror("../../WindowMaker/Icons");
1114         return;
1115     }
1116
1117     for (i = 0, j=0; j < 8; i++) {
1118         ent = readdir(dir);
1119         if (!ent)
1120             break;
1121
1122         if (strstr(ent->d_name, ".xpm")==NULL) {
1123             continue;
1124         }
1125
1126         label = makeDraggableLabel(frame, ent->d_name,4+(j/4)*64, 4+(j%4)*64);
1127
1128         j++;
1129     }
1130
1131     closedir(dir);
1132
1133     WMMapSubwidgets(frame);
1134
1135     WMMapSubwidgets(win);
1136     WMRealizeWidget(win);
1137     WMMapWidget(win);
1138 }
1139
1140
1141
1142
1143
1144 /*******************************************************************/
1145
1146 #include "WUtil.h"
1147
1148 void
1149 testUD()
1150 {
1151     WMUserDefaults *defs;
1152     char str[32];
1153
1154     defs = WMGetStandardUserDefaults();
1155
1156     sprintf(str, "TEST DATA");
1157     puts(str);
1158     WMSetUDStringForKey(defs, str, "testKey");
1159     puts(str);
1160 }
1161
1162
1163 int
1164 main(int argc, char **argv)
1165 {
1166     WMScreen *scr;
1167     WMPixmap *pixmap;
1168
1169
1170     /* Initialize the application */
1171     WMInitializeApplication("Test", &argc, argv);
1172
1173     testUD();
1174
1175     /*
1176      * Open connection to the X display.
1177      */
1178     dpy = XOpenDisplay("");
1179
1180     if (!dpy) {
1181         puts("could not open display");
1182         exit(1);
1183     }
1184
1185     /* This is used to disable buffering of X protocol requests.
1186      * Do NOT use it unless when debugging. It will cause a major
1187      * slowdown in your application
1188      */
1189 #if 1
1190     XSynchronize(dpy, True);
1191 #endif
1192     /*
1193      * Create screen descriptor.
1194      */
1195     scr = WMCreateScreen(dpy, DefaultScreen(dpy));
1196
1197     /*
1198      * Loads the logo of the application.
1199      */
1200     pixmap = WMCreatePixmapFromFile(scr, "logo.xpm");
1201
1202     /*
1203      * Makes the logo be used in standard dialog panels.
1204      */
1205     WMSetApplicationIconImage(scr, pixmap); WMReleasePixmap(pixmap);
1206
1207     /*
1208      * Do some test stuff.
1209      *
1210      * Put the testSomething() function you want to test here.
1211      */
1212
1213     testList(scr);
1214
1215 #if 0
1216     testColorWell(scr);
1217
1218     testTextField(scr);
1219     testText(scr);
1220
1221     testDragAndDrop(scr);
1222     testDragAndDrop(scr);
1223     testFontPanel(scr);
1224
1225     testScrollView(scr);
1226
1227     testButton(scr);
1228
1229     testFrame(scr);
1230
1231
1232     testTabView(scr);
1233
1234
1235
1236     testSplitView(scr);
1237
1238     testGradientButtons(scr);
1239     testProgressIndicator(scr);
1240
1241
1242     testOpenFilePanel(scr);
1243
1244     testSlider(scr);
1245     testPullDown(scr);
1246 #endif
1247     /*
1248      * The main event loop.
1249      *
1250      */
1251     WMScreenMainLoop(scr);
1252
1253     return 0;
1254 }