gtkD/src/gtk/Calendar.d

   1 /*
   2  * This file is part of gtkD.
   3  *
   4  * gtkD is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = GtkCalendar.html
  26  * outPack = gtk
  27  * outFile = Calendar
  28  * strct   = GtkCalendar
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = Calendar
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gtk_calendar_
  40  *      - gtk_
  41  * omit structs:
  42  * omit prefixes:
  43  * omit code:
  44  * imports:
  45  * structWrap:
  46  * module aliases:
  47  * local aliases:
  48  */
  49
  50 module gtk.Calendar;
  51
  52 version(noAssert)
  53 {
  54         version(Tango)
  55         {
  56                 import tango.io.Stdout; // use the tango loging?
  57         }
  58 }
  59
  60 private import gtkc.gtktypes;
  61
  62 private import gtkc.gtk;
  63
  64
  65
  66
  67
  68
  69 /**
  70  * Description
  71  * GtkCalendar is a widget that displays a calendar, one month at a time.
  72  * It can be created with gtk_calendar_new().
  73  * The month and year currently displayed can be altered with
  74  * gtk_calendar_select_month(). The exact day can be selected from the displayed
  75  * month using gtk_calendar_select_day().
  76  * To place a visual marker on a particular day, use gtk_calendar_mark_day()
  77  * and to remove the marker, gtk_calendar_unmark_day().
  78  * Alternative, all marks can be cleared with gtk_calendar_clear_marks().
  79  * The way in which the calendar itself is displayed can be altered using
  80  * gtk_calendar_set_display_options().
  81  * The selected date can be retrieved from a GtkCalendar using
  82  * gtk_calendar_get_date().
  83  */
  84 private import gtk.Widget;
  85 public class Calendar : Widget
  86 {
  87
  88         /** the main Gtk struct */
  89         protected GtkCalendar* gtkCalendar;
  90
  91
  92         public GtkCalendar* getCalendarStruct()
  93         {
  94                 return gtkCalendar;
  95         }
  96
  97
  98         /** the main Gtk struct as a void* */
  99         protected void* getStruct()
 100         {
 101                 return cast(void*)gtkCalendar;
 102         }
 103
 104         /**
 105          * Sets our main struct and passes it to the parent class
 106          */
 107         public this (GtkCalendar* gtkCalendar)
 108         {
 109                 version(noAssert)
 110                 {
 111                         if ( gtkCalendar is null )
 112                         {
 113                                 int zero = 0;
 114                                 version(Tango)
 115                                 {
 116                                         Stdout("struct gtkCalendar is null on constructor").newline;
 117                                 }
 118                                 else
 119                                 {
 120                                         printf("struct gtkCalendar is null on constructor");
 121                                 }
 122                                 zero = zero / zero;
 123                         }
 124                 }
 125                 else
 126                 {
 127                         assert(gtkCalendar !is null, "struct gtkCalendar is null on constructor");
 128                 }
 129                 super(cast(GtkWidget*)gtkCalendar);
 130                 this.gtkCalendar = gtkCalendar;
 131         }
 132
 133         /**
 134          */
 135
 136         // imports for the signal processing
 137         private import gobject.Signals;
 138         private import gtkc.gdktypes;
 139         int[char[]] connectedSignals;
 140
 141         void delegate(Calendar)[] onDaySelectedListeners;
 142         void addOnDaySelected(void delegate(Calendar) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 143         {
 144                 if ( !("day-selected" in connectedSignals) )
 145                 {
 146                         Signals.connectData(
 147                         getStruct(),
 148                         "day-selected",
 149                         cast(GCallback)&callBackDaySelected,
 150                         cast(void*)this,
 151                         null,
 152                         connectFlags);
 153                         connectedSignals["day-selected"] = 1;
 154                 }
 155                 onDaySelectedListeners ~= dlg;
 156         }
 157         extern(C) static void callBackDaySelected(GtkCalendar* calendarStruct, Calendar calendar)
 158         {
 159                 bool consumed = false;
 160
 161                 foreach ( void delegate(Calendar) dlg ; calendar.onDaySelectedListeners )
 162                 {
 163                         dlg(calendar);
 164                 }
 165
 166                 return consumed;
 167         }
 168
 169         void delegate(Calendar)[] onDaySelectedDoubleClickListeners;
 170         void addOnDaySelectedDoubleClick(void delegate(Calendar) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 171         {
 172                 if ( !("day-selected-double-click" in connectedSignals) )
 173                 {
 174                         Signals.connectData(
 175                         getStruct(),
 176                         "day-selected-double-click",
 177                         cast(GCallback)&callBackDaySelectedDoubleClick,
 178                         cast(void*)this,
 179                         null,
 180                         connectFlags);
 181                         connectedSignals["day-selected-double-click"] = 1;
 182                 }
 183                 onDaySelectedDoubleClickListeners ~= dlg;
 184         }
 185         extern(C) static void callBackDaySelectedDoubleClick(GtkCalendar* calendarStruct, Calendar calendar)
 186         {
 187                 bool consumed = false;
 188
 189                 foreach ( void delegate(Calendar) dlg ; calendar.onDaySelectedDoubleClickListeners )
 190                 {
 191                         dlg(calendar);
 192                 }
 193
 194                 return consumed;
 195         }
 196
 197         void delegate(Calendar)[] onMonthChangedListeners;
 198         void addOnMonthChanged(void delegate(Calendar) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 199         {
 200                 if ( !("month-changed" in connectedSignals) )
 201                 {
 202                         Signals.connectData(
 203                         getStruct(),
 204                         "month-changed",
 205                         cast(GCallback)&callBackMonthChanged,
 206                         cast(void*)this,
 207                         null,
 208                         connectFlags);
 209                         connectedSignals["month-changed"] = 1;
 210                 }
 211                 onMonthChangedListeners ~= dlg;
 212         }
 213         extern(C) static void callBackMonthChanged(GtkCalendar* calendarStruct, Calendar calendar)
 214         {
 215                 bool consumed = false;
 216
 217                 foreach ( void delegate(Calendar) dlg ; calendar.onMonthChangedListeners )
 218                 {
 219                         dlg(calendar);
 220                 }
 221
 222                 return consumed;
 223         }
 224
 225         void delegate(Calendar)[] onNextMonthListeners;
 226         void addOnNextMonth(void delegate(Calendar) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 227         {
 228                 if ( !("next-month" in connectedSignals) )
 229                 {
 230                         Signals.connectData(
 231                         getStruct(),
 232                         "next-month",
 233                         cast(GCallback)&callBackNextMonth,
 234                         cast(void*)this,
 235                         null,
 236                         connectFlags);
 237                         connectedSignals["next-month"] = 1;
 238                 }
 239                 onNextMonthListeners ~= dlg;
 240         }
 241         extern(C) static void callBackNextMonth(GtkCalendar* calendarStruct, Calendar calendar)
 242         {
 243                 bool consumed = false;
 244
 245                 foreach ( void delegate(Calendar) dlg ; calendar.onNextMonthListeners )
 246                 {
 247                         dlg(calendar);
 248                 }
 249
 250                 return consumed;
 251         }
 252
 253         void delegate(Calendar)[] onNextYearListeners;
 254         void addOnNextYear(void delegate(Calendar) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 255         {
 256                 if ( !("next-year" in connectedSignals) )
 257                 {
 258                         Signals.connectData(
 259                         getStruct(),
 260                         "next-year",
 261                         cast(GCallback)&callBackNextYear,
 262                         cast(void*)this,
 263                         null,
 264                         connectFlags);
 265                         connectedSignals["next-year"] = 1;
 266                 }
 267                 onNextYearListeners ~= dlg;
 268         }
 269         extern(C) static void callBackNextYear(GtkCalendar* calendarStruct, Calendar calendar)
 270         {
 271                 bool consumed = false;
 272
 273                 foreach ( void delegate(Calendar) dlg ; calendar.onNextYearListeners )
 274                 {
 275                         dlg(calendar);
 276                 }
 277
 278                 return consumed;
 279         }
 280
 281         void delegate(Calendar)[] onPrevMonthListeners;
 282         void addOnPrevMonth(void delegate(Calendar) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 283         {
 284                 if ( !("prev-month" in connectedSignals) )
 285                 {
 286                         Signals.connectData(
 287                         getStruct(),
 288                         "prev-month",
 289                         cast(GCallback)&callBackPrevMonth,
 290                         cast(void*)this,
 291                         null,
 292                         connectFlags);
 293                         connectedSignals["prev-month"] = 1;
 294                 }
 295                 onPrevMonthListeners ~= dlg;
 296         }
 297         extern(C) static void callBackPrevMonth(GtkCalendar* calendarStruct, Calendar calendar)
 298         {
 299                 bool consumed = false;
 300
 301                 foreach ( void delegate(Calendar) dlg ; calendar.onPrevMonthListeners )
 302                 {
 303                         dlg(calendar);
 304                 }
 305
 306                 return consumed;
 307         }
 308
 309         void delegate(Calendar)[] onPrevYearListeners;
 310         void addOnPrevYear(void delegate(Calendar) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
 311         {
 312                 if ( !("prev-year" in connectedSignals) )
 313                 {
 314                         Signals.connectData(
 315                         getStruct(),
 316                         "prev-year",
 317                         cast(GCallback)&callBackPrevYear,
 318                         cast(void*)this,
 319                         null,
 320                         connectFlags);
 321                         connectedSignals["prev-year"] = 1;
 322                 }
 323                 onPrevYearListeners ~= dlg;
 324         }
 325         extern(C) static void callBackPrevYear(GtkCalendar* calendarStruct, Calendar calendar)
 326         {
 327                 bool consumed = false;
 328
 329                 foreach ( void delegate(Calendar) dlg ; calendar.onPrevYearListeners )
 330                 {
 331                         dlg(calendar);
 332                 }
 333
 334                 return consumed;
 335         }
 336
 337
 338
 339
 340         /**
 341          * Creates a new calendar, with the current date being selected.
 342          * Returns:
 343          *  a newly GtkCalendar widget
 344          */
 345         public this ()
 346         {
 347                 // GtkWidget* gtk_calendar_new (void);
 348                 this(cast(GtkCalendar*)gtk_calendar_new() );
 349         }
 350
 351         /**
 352          * Shifts the calendar to a different month.
 353          * calendar:
 354          *  a GtkCalendar
 355          * month:
 356          *  a month number between 0 and 11.
 357          * year:
 358          *  the year the month is in.
 359          * Returns:
 360          *  TRUE, always
 361          */
 362         public int selectMonth(uint month, uint year)
 363         {
 364                 // gboolean gtk_calendar_select_month (GtkCalendar *calendar,  guint month,  guint year);
 365                 return gtk_calendar_select_month(gtkCalendar, month, year);
 366         }
 367
 368         /**
 369          * Selects a day from the current month.
 370          * calendar:
 371          *  a GtkCalendar.
 372          * day:
 373          *  the day number between 1 and 31, or 0 to unselect
 374          *  the currently selected day.
 375          */
 376         public void selectDay(uint day)
 377         {
 378                 // void gtk_calendar_select_day (GtkCalendar *calendar,  guint day);
 379                 gtk_calendar_select_day(gtkCalendar, day);
 380         }
 381
 382         /**
 383          * Places a visual marker on a particular day.
 384          * calendar:
 385          *  a GtkCalendar
 386          * day:
 387          *  the day number to mark between 1 and 31.
 388          * Returns:
 389          *  TRUE, always
 390          */
 391         public int markDay(uint day)
 392         {
 393                 // gboolean gtk_calendar_mark_day (GtkCalendar *calendar,  guint day);
 394                 return gtk_calendar_mark_day(gtkCalendar, day);
 395         }
 396
 397         /**
 398          * Removes the visual marker from a particular day.
 399          * calendar:
 400          *  a GtkCalendar.
 401          * day:
 402          *  the day number to unmark between 1 and 31.
 403          * Returns:
 404          *  TRUE, always
 405          */
 406         public int unmarkDay(uint day)
 407         {
 408                 // gboolean gtk_calendar_unmark_day (GtkCalendar *calendar,  guint day);
 409                 return gtk_calendar_unmark_day(gtkCalendar, day);
 410         }
 411
 412         /**
 413          * Remove all visual markers.
 414          * calendar:
 415          *  a GtkCalendar
 416          */
 417         public void clearMarks()
 418         {
 419                 // void gtk_calendar_clear_marks (GtkCalendar *calendar);
 420                 gtk_calendar_clear_marks(gtkCalendar);
 421         }
 422
 423         /**
 424          * Returns the current display options of calendar.
 425          * calendar:
 426          *  a GtkCalendar
 427          * Returns:
 428          *  the display options.
 429          * Since 2.4
 430          */
 431         public GtkCalendarDisplayOptions getDisplayOptions()
 432         {
 433                 // GtkCalendarDisplayOptions gtk_calendar_get_display_options  (GtkCalendar *calendar);
 434                 return gtk_calendar_get_display_options(gtkCalendar);
 435         }
 436
 437         /**
 438          * Sets display options (whether to display the heading and the month
 439          * headings).
 440          * calendar:
 441          *  a GtkCalendar
 442          * flags:
 443          *  the display options to set
 444          * Since 2.4
 445          */
 446         public void setDisplayOptions(GtkCalendarDisplayOptions flags)
 447         {
 448                 // void gtk_calendar_set_display_options (GtkCalendar *calendar,  GtkCalendarDisplayOptions flags);
 449                 gtk_calendar_set_display_options(gtkCalendar, flags);
 450         }
 451
 452         /**
 453          * Warning
 454          * gtk_calendar_display_options is deprecated and should not be used in newly-written code.
 455          * Sets display options (whether to display the heading and the month headings).
 456          * calendar:
 457          *  a GtkCalendar.
 458          * flags:
 459          *  the display options to set.
 460          */
 461         public void displayOptions(GtkCalendarDisplayOptions flags)
 462         {
 463                 // void gtk_calendar_display_options (GtkCalendar *calendar,  GtkCalendarDisplayOptions flags);
 464                 gtk_calendar_display_options(gtkCalendar, flags);
 465         }
 466
 467         /**
 468          * Obtains the selected date from a GtkCalendar.
 469          * calendar:
 470          *  a GtkCalendar
 471          * year:
 472          *  location to store the year number, or NULL
 473          * month:
 474          *  location to store the month number (between 0 and 11), or NULL
 475          * day:
 476          *  location to store the day number (between 1 and 31), or NULL
 477          */
 478         public void getDate(uint* year, uint* month, uint* day)
 479         {
 480                 // void gtk_calendar_get_date (GtkCalendar *calendar,  guint *year,  guint *month,  guint *day);
 481                 gtk_calendar_get_date(gtkCalendar, year, month, day);
 482         }
 483
 484         /**
 485          * Warning
 486          * gtk_calendar_freeze has been deprecated since version 2.8 and should not be used in newly-written code.
 487          * Does nothing. Previously locked the display of the calendar until
 488          * it was thawed with gtk_calendar_thaw().
 489          * calendar:
 490          *  a GtkCalendar
 491          */
 492         public void freeze()
 493         {
 494                 // void gtk_calendar_freeze (GtkCalendar *calendar);
 495                 gtk_calendar_freeze(gtkCalendar);
 496         }
 497
 498         /**
 499          * Warning
 500          * gtk_calendar_thaw has been deprecated since version 2.8 and should not be used in newly-written code.
 501          * Does nothing. Previously defrosted a calendar; all the changes made
 502          * since the last gtk_calendar_freeze() were displayed.
 503          * calendar:
 504          *  a GtkCalendar
 505          * Property Details
 506          * The "day" property
 507          *  "day" gint : Read / Write
 508          * The selected day (as a number between 1 and 31, or 0 to unselect the currently selected day).
 509          * Allowed values: [0,31]
 510          * Default value: 0
 511          */
 512         public void thaw()
 513         {
 514                 // void gtk_calendar_thaw (GtkCalendar *calendar);
 515                 gtk_calendar_thaw(gtkCalendar);
 516         }
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529 }