साधनाक्षेत्र

'तत्त्वालोचना की दृष्टि से मनुष्य शरीर में अलग-अलग तीन खंड हैं। मूलाधार से आज्ञाचक्र पर्यन्त जो षट्चक्र हैं, यहाँ तक कि ऊर्ध्व में सहस्त्रारचक्र तक भी, प्रथम खंड के अंतर्गत है। इसके बाद व्यापक शून्य का अनुभव होता है। इस शून्य को भेद कर सकने पर देह के द्वितीयखंड में प्रवेश हो सकता है। इस द्वितीयखंड के प्रवेश के साथ ही साथ अति विशाल तेजपुंज का साक्षात्कार होता है। यह प्रकाश कोटि-कोटि सूर्य की सम्मिलित प्रभा से भी कहीं अधिक दीप्तिमान है। कोई-कोई साधक सहस्त्रार भेद करके, यहाँ तक कि तदतीत शून्य को भी भेद करके, इस महातेज के भीतर जाकर लीन हो जाते हैं, अर्थात् इसको भेद नहीं कर पाते।
 

इस तेज में प्रवेश करने पर पता चलता है कि इसमें तीन पृथक् पृथक् विभाग हैं। पहले विभाग का नाम 'अक्षर' है। यह भी एक प्रकार शून्य ही है। द्वितीय विभाग का नाम 'निरक्षर' है-इसका स्वरूप महाशून्य है। इस मार्ग में आगे बढ़ने पर 'सहजपथ' मिलता है, तब 'अचिंत्य-परब्रह्मपद' की प्राप्ति होती है। जो लोग 'अक्षर-भूमि' में रहते हैं, उनकी स्थिति शून्य में ही होती है। परन्तु जो भाग्यवान हैं वे 'निरक्षर-भूमि' में जा सकते हैं और 'अचिन्त्य परब्रह्मपद' तक उठते हैं। इसके बाद और कोई मार्ग नहीं है। परंतु 'निरक्षर' से भी अतीतावस्था है। अगर कोई वहाँ तक जा सके तो उसको पहले 'सत्यलोक' मिलता है, उसके बाद 'कुमार लोक' और अंत में 'उमालोक'। यहीं तक ऊर्ध्वगति हो सकती है। इनके अनंतर और कहीं जाने के मार्ग का पता नहीं चलता।'

(related: કુંડલિની જાગૃત ≠ સમાધિ) 

~ सीतारामदास बाबा, मनीषी की लोकयात्रा

સંસારી સંન્યાસી

શ્યામાચરણે પૂછયું કે સાંસારિક કાર્યવ્યસ્તતા વચ્ચે કઠોર સાધના કેવી રીતે કરી શકાશે એ વાત તેમને માટે અસંભવ જેવી પ્રતીત થઈ રહી છે. તેને માટે સમય ક્યાં મળશે?

બાબાજીએ કહ્યું : “ના, શ્યામાચરણ તમે ગૃહસ્થીમાં જઈ તો જુઓ. તમને ઘણો સમય મળશે. સમયાનુસાર તમારી બદલી કાશીમાં થઈ જશે અને તમે સુખી રહેશો. તમે સ્વયં ગૃહસ્થ જીવનમાં રહીને જ સાધના દ્વારા સિધ્ધિ પ્રાપ્ત કરશો ત્યારે તમારા આદર્શોનો સંસારીઓ સ્વીકાર કરશે. એ પણ જાણી લો કે કોઇ સંસારને ત્યાગી નથી શકતું. તેનાથી કોઈ કદી અલગ રહી નથી શકતું. મનુષ્ય ચાહે ત્યાં રહે, સંસાર તેની સાથે રહેશે. તે સિવાય સાંસારિક લોકોએ જ આ દુનિયાને આટલી સુંદર બનાવી રાખી છે, આટલો વૈભવવિલાસ આપી રાખ્યો છે. એ ન હોત તો પૃથ્વી આટલી સુંદર ન હોત. સાંસારિક જીવનને અભાવે ઇશ્વરની સૃષ્ટિ નષ્ટ થઈ જાત. બધા આ સંસારમાં જન્મ લે છે. ઈશ્વરની સાધના કેવળ સંસારત્યાગી કે વિરક્ત લોકોને માટે ન હોઇ શકે. જુઓ, હું સંન્યાસી હોવા છતાં જે પાત્રમાં જળ પીઉં છું તે પણ સંસારી વ્યક્તિનું જ બનાવેલું છે.” દયાશીલ બાબાએ વધુમાં કહ્યું: “આજે સંસારી મનુષ્ય ઇશ્વરસાધનાના વિષયમાં સાવ નિરુપાય છે. તમે સ્વયં સંસારમાં રહીને તેમને સાચો રસ્તો દેખાડશો. ભયની કોઈ વાત નથી, તમે ઘેર પાછા જાઓ. યથાસમયે અવારનવાર તમે મને જોઈ શકશો અને જ્યારે પણ તમે મને જોવાની ઇચ્છા કરશો, જોઈ શકશો. સંસારમાં સદ્દગૃહસ્થોની પ્રતિષ્ઠા થાય.” ત્યાર બાદ બાબાજીએ પાસે બેઠેલા થોડા લોકો તરફ સંકેત કરતાં કહ્યું : “તમારે આ લોકોને દીક્ષા આપવી પડશે. તમારે માટે જ આટલા દિવસ સુધી એમને રોકી રાખ્યા છે.”

~ પુરાણ પુરુષ યોગીરાજ શ્રી શ્યામાચરણ લાહિરી 

Button - Elementary - EFL

Description

This is a push-button. Press it and run some function. Button can have text, icon and text, or icon only. This widget inherits from the Layout widget. So that all the functions acting on Layout widget also work for Button widget.

Default content parts of the button widget that you can use for are:

"icon"
An icon of the button

Default text parts of the button widget that you can use for are:

"default"
A label of the button

Screenshots

Examples

#include <Elementary.h>

static void _on_delete_request(void* data, Evas_Object* obj, void* event_info) {
  elm_exit();
}

static void _on_btn_clicked(void* data, Evas_Object* obj, void* event_info) {
  const char* name = data;
  printf("%s clicked\n", name);
}

int main(int argc, char* argv[]) {
  elm_init(argc, argv);

  // Window
  Evas_Object* win = elm_win_util_standard_add("btns", "btns");
  elm_win_autodel_set(win, EINA_TRUE);
  evas_object_smart_callback_add(win, "delete,request", _on_delete_request, NULL);
  evas_object_resize(win, 300, 300);

  // Box
  Evas_Object* box = elm_box_add(win);
  evas_object_size_hint_weight_set(box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  evas_object_size_hint_align_set(box, EVAS_HINT_FILL, EVAS_HINT_FILL);
  elm_win_resize_object_add(win, box);
  evas_object_show(box);

  // Button
  Evas_Object* btn1 = elm_button_add(win);
  elm_object_text_set(btn1, "Button");
  evas_object_size_hint_weight_set(btn1, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  evas_object_size_hint_align_set(btn1, EVAS_HINT_FILL, EVAS_HINT_FILL);
  evas_object_smart_callback_add(btn1, "clicked", _on_btn_clicked, "Button");
  elm_box_pack_end(box, btn1);
  evas_object_show(btn1);

  // Icon + Button
  Evas_Object* btn2 = elm_button_add(win);
  elm_object_text_set(btn2, "Button");

  Evas_Object* icon1 = elm_icon_add(win);
  elm_icon_standard_set(icon1, "go-home");
  evas_object_show(icon1);

  elm_object_part_content_set(btn2, "icon", icon1);

  evas_object_size_hint_weight_set(btn2, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  evas_object_size_hint_align_set(btn2, EVAS_HINT_FILL, EVAS_HINT_FILL);
  evas_object_smart_callback_add(btn2, "clicked", _on_btn_clicked, "Button 2");
  elm_box_pack_end(box, btn2);
  evas_object_show(btn2);

  // Icon
  Evas_Object* btn3 = elm_button_add(win);

  Evas_Object* icon2 = elm_icon_add(win);
  elm_icon_standard_set(icon2, "go-home");
  evas_object_show(icon2);

  elm_object_part_content_set(btn3, "icon", icon2);

  evas_object_size_hint_weight_set(btn3, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
  evas_object_size_hint_align_set(btn3, EVAS_HINT_FILL, EVAS_HINT_FILL);
  evas_object_smart_callback_add(btn3, "clicked", _on_btn_clicked, "Icon Button");
  elm_box_pack_end(box, btn3);
  evas_object_show(btn3);

  evas_object_show(win);
  
  elm_run();
  elm_shutdown();

  return 0;
}

Heirarchy

+---------+
| widget  |
+---------+
     |
     v
+-----------+
| container |
+-----------+
     |
     v
+--------+
| layout |
+--------+
     |
     v
+--------+
| button |
+--------+

Signals

clicked
Emitted when button is clicked (pressed and released).

pressed
Emitted when `button` is pressed.

unpressed
Emitted when button is released after being pressed.

focused (since 1.8)
Emitted when button has received focus.

unfocused (since 1.8)
Emitted when button has lost focus.

repeated
Emitted when button is pressed without releasing it.

Following are the signals inherited from Layout widgets.

"theme,changed"
Emitted when theme is changed.

"language,changed"
Emitted when application's language changed.

Styles

Defined in the default theme, the button has the following styles available:

default
A normal button.

anchor
Like default, but the button fades away when the mouse is not over it, leaving only the text or icon.

hoversel_vertical (internal)
Internally used by Hoversel to give a continuous look across its options.

hoversel_vertical_entry (internal)
Another internal for Hoversel.

naviframe (internal)
Internally used by Elm_Naviframe for its back button.

colorselector (internal)
Internally used by Colorselector for its left and right buttons.

Constructors

elm_button_add
Add a new button to the parent's canvas.

Functions

elm_button_autorepeat_initial_timeout_set
Sets the initial timeout before the autorepeat event is generated.

elm_button_autorepeat_initial_timeout_get
Gets the initial timeout before the autorepeat event is generated.

elm_button_autorepeat_gap_timeout_set
Sets the interval between each generated autorepeat event.

elm_button_autorepeat_gap_timeout_get
Gets the interval between each generated autorepeat event.

elm_button_autorepeat_set
Sets the autorepeat event generated when the button is kept pressed.

elm_button_autorepeat_get
Gets the autorepeat event generated when the button is kept pressed.

Following are the functions inherited from the Container class.

elm_object_part_text_set
Sets the text of an object.

elm_object_part_text_get
Gets the text of an object.

elm_object_part_content_set
Set the content on part of a given container widget.

elm_object_part_content_get
Get the content on part of a given container widget.

elm_object_part_content_unset
Unsets the content on a part of a given container widget.

elm_object_signal_emit
Sends the signal to the widget.

elm_object_signal_callback_add
Adds the callback for a signal emitted by widget.

elm_object_signal_callback_del
Removes a signal-triggered callback from a widget.

इच्छा

सृष्टि के मूल में है इच्छा। एक दृष्टांत लो। कुम्हार ने घटादि बनाने के लिए कुलाल चक्र को घुमा दिया। थोड़ी सी मिट्टी का पिड है और उस पर उसने हाथ लगा रखा है। कैसा आश्चर्य है! हाथ हिलता नहीं और कुम्हार की इच्छा के अनुसार कभी घड़ा, कभी सकोरा और कभी हाँड़ी तैयार हो जाती है। इच्छा से ही सब होता है। उपादान तो नित्य ही है सत् अथवा सत्ता, कालचक्र घूम ही रहा है, अब केवल इच्छा ही उत्पत्ति का नियामक है।

यह बात याद रखनी चाहिए कि इच्छा ही बीज है। जो इच्छा करोगे वही होगा, निश्चय ही होगा। आज नहीं तो कल। इच्छा का नाश नहीं होता। एक बार जो इच्छा की गयी, तत्काल वह अनंत में चित्रित हो गयी। समय आने पर फूटकर बाहर निकल आयेगी। मान लो तुम्हें आज घास खाने की इच्छा हुई अतएव तुम्हें एक ऐसा शरीर धारण करना पड़ेगा जिससे घास खाने की इच्छा पूर्ण हो सकती है। ऐसा शरीर धारण किये बिना वह इच्छा अतृप्त रह जायगी। जिस प्रकार की इच्छा होती है शरीर भी उसी प्रकार का धारण करना पड़ता है, चाहे वह देव शरीर हो, मानव शरीर हो या तिर्यक् शरीर। शरीर धारण किये बिना काम नहीं चल सकता। एक कथा है-
 

एक बार बुद्धदेव का एक भक्त अत्यंत भक्तिपूर्वक गुरुदेव के लिए सूअर का मांस तैयार करके उनके आगमन की प्रतीक्षा में बैठा था। सारा दिन बीत गया, संध्या हो गयी परंतु गुरुदेव नहीं आये। संध्या के समय एक कुत्ते ने आकर उस मांस में जो भगवान् के लिए यत्नपूर्वक रखा गया था, मुँह डाल दिया तथा उसमें से कुछ खा भी लिया। भक्त ने देखते ही कुत्ते को भगा दिया। परंतु उस दिन बुद्धदेव नहीं पधारे। दूसरे दिन उसने जाकर बुद्धदेव से सब वृत्तांत कहा और यह भी प्रकट किया कि आपके न पधारने से मेरे हृदय में बड़ा ही दुःख हुआ था। बुद्धदेव ने कहा "मैं तो कल गया था और मैंने तुम्हारे भोग को ग्रहण भी किया था। तुम मुझे पहचान नहीं सके। कल क्या तुमने एक कुत्ता नहीं देखा, मैं ही कुत्ते का शरीर धारण करके गया था। तुमने मेरे लिए जिस प्रकार का भोग रखा था, उसके अनुरूप देह धारण करके ही मैं गया था।" अतएव समझना चाहिए कि सब शरीरों में सब प्रकार के भोग नहीं हो सकते।
 

इच्छा की तृप्ति हुए बिना मुक्ति नहीं होती। जब तक एक भी वासना अतृप्त रहेगी, तब तक मुक्ति असंभव है। 

~ मनीषी की लोकयात्रा 

Let's Build Peter Pt. 4

Since the backend is working, we can now start using the middleware packages we installed earlier.

Let's begin with morgan.

import express from "express";
import morgan from "morgan";

const app = express();

app.use(morgan("tiny"));

app.get("/ping", (req, res) => {
    return res.json({ data: "pong" });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`http://localhost:${PORT}`);
});

Now that logging is in place, the next middleware we will configure is cors. We will whitelist the React application's URL: http://localhost:5173.

import express from "express";
import morgan from "morgan";
import cors from "cors";

const app = express();

app.use(morgan("tiny"));
app.use(
    cors({
        origin: "http://localhost:5173",
    }),
);

app.get("/ping", (req, res) => {
    return res.json({ data: "pong" });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`http://localhost:${PORT}`);
});

Finally, let's add helmet and compression.

import express from "express";
import morgan from "morgan";
import cors from "cors";
import helmet from "helmet";
import compression from "compression";

const app = express();

app.use(morgan("tiny"));
app.use(
    cors({
        origin: "http://localhost:5173",
    }),
);
app.use(helmet());
app.use(compression());

app.get("/ping", (req, res) => {
    return res.json({ data: "pong" });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`http://localhost:${PORT}`);
});

Perfect! Now visit http://localhost:3000/ping. It should return the same output as before. However, this time you will also see the request being logged in the terminal.

Yes — it’s working for me 👍

Now is a good time to open Insomnia (or any other API client). Send a request to the same endpoint and confirm that you receive: { "data": "pong" }

Cleaning Up the Frontend

On the frontend side, let’s clean up the scaffolded application:

• Remove the public folder
• Remove the src/assets folder
• Remove the App.css file

After cleaning up, your folder structure should look minimal and clean.

Now open the App.jsx file and replace its content with the following:

const App = () => {
    return <h1>hello, world</h1>;
};

export default App;

Run the React application using:

npm run dev

Within a few seconds, the application should be available at: http://localhost:5173. Visit the URL and confirm that you see: hello, world.

Both applications are now running — yay! 🎉

શ્રદ્ધાનું જોર

શ્રીરામકૃષ્ણ - (કેદારને) શ્રદ્ધાનું જોર કેટલું છે તે તો સાંભળ્યું છે ને? પુરાણમાં કહ્યું છે કે રામચંદ્ર કે જે સાક્ષાત્ પૂર્ણ બ્રહ્મ નારાયણ, તેમને લંકામાં પહોંચવા સારુ પુલ બાંધવો પડ્યો, પણ હનુમાન રામનામમાં શ્રદ્ધા રાખીને એક જ છલાંગે સમુદ્રની પેલી પાર કૂદી પડયા. તેમને પુલની જરૂર નહિ. (સૌનું હાસ્ય)

~ શ્રીરામકૃષ્ણ કથામૃતમાંથી

Let's Build Peter Pt. 3

Inside the backend folder, let’s create an app.js file and write some base code to test our setup.

touch app.js

We will use the modern import...from syntax. We’ll update the necessary configuration in the package.json file shortly.

import express from "express";

const app = express();

Now, let’s define a /ping route that returns "pong" as a JSON response.

import express from "express";

const app = express();

app.get("/ping", (req, res) => {
    return res.json({ data: "pong" });
});

💡 Tip: Always use return when you want to stop the execution of a function after sending a response.

We will use port 3000 because the React application created using Vite runs on port 5173 by default.

import express from "express";

const app = express();

app.get("/ping", (req, res) => {
    return res.json({ data: "pong" });
});

const PORT = process.env.PORT || 3000;

Finally, let’s start the server and print the URL for future reference and debugging.

import express from "express";

const app = express();

app.get("/ping", (req, res) => {
    return res.json({ data: "pong" });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`http://localhost:${PORT}`);
});

We need to make the following changes in the package.json file:

• Change "type" from "commonjs" to "module" to support the import...from syntax.
• Change "main" from index.js to app.js.

{
    "name": "backend",
    "version": "1.0.0",
    "description": "",
    "main": "app.js",
    "scripts": {
        "test": "echo \"Error: no test specified\" && exit 1"
    },
    "keywords": [],
    "author": "",
    "license": "ISC",
    "type": "module",
    "dependencies": {
        "compression": "1.8.1",
        "cors": "2.8.6",
        "express": "5.2.1",
        "helmet": "8.1.0",
        "morgan": "1.10.1",
        "postgres": "3.4.8"
    }
}

I almost forgot — we also need nodemon to automatically restart the server when files change during development.

💡 Tip: This is an example of a non-perfect setup. You will always miss something — and that’s completely fine.

Install nodemon as a development dependency:

npm i -E -D nodemon

Now, let’s add two scripts to package.json:

• dev → runs nodemon app.js
• start → runs node app.js

{
    "name": "backend",
    "version": "1.0.0",
    "description": "",
    "main": "app.js",
    "scripts": {
        "dev": "nodemon app.js",
        "start": "node app.js"
    },
    "keywords": [],
    "author": "",
    "license": "ISC",
    "type": "module",
    "dependencies": {
        "compression": "1.8.1",
        "cors": "2.8.6",
        "express": "5.2.1",
        "helmet": "8.1.0",
        "morgan": "1.10.1",
        "postgres": "3.4.8"
    },
    "devDependencies": {
        "nodemon": "3.1.11"
    }
}

With these changes, we are ready to run the application. Both scripts will start the server, but during development, we usually use:

npm run dev

Now open your browser and visit http://localhost:3000/ping. You should see { "data": "pong" } And yup — it’s working! 🎉 If everything works on your side, you’re ready to head over to the next article.