WINGs/Tests/wtest.c

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